What are Deepfakes? Deepfakes are manufactured works of art in which the likeness of a different person is used to replace a real person in a photograph or video.

GANs utilize a deep learning approach in which two neural networks compete with each other. The two neural networks which are used are named as generative network and discriminative network. After being trained, the generative network will be able to create a new image using the information from an input image that appears to human observers to be essentially legitimate. The discriminative network is in charge of determining/classifying whether the input is a real image or a false one.

The generator and discriminator are constantly participating in an optimal two player game (min-max approach) during training. The aim of the generative network will be to create images such that it can trick the discriminator into thinking that the created image is authentic and not a fake one. The aim of the discriminative network will be to correctly classify the real and fake images. GANs require paired training samples to help the model learn what an output from the generator should look like.

Below is the architecture of a Generative Adversarial Network

Working:-

1. Random input is passed to the generator. The generator processes the input to produce new images
2. The image generated by generator is given as input to the discriminator along with a set of real images
3. The discriminator processes the input images, compares them and tries to determine whether the image generated by generator is real or fake
4. Based on whether the discriminator is able to classify correctly or not, and whether generator is able to create images which look authentic or not, the generative and discriminative loss functions are calculated. The loss functions are used as a feedback signal to improve the neural networks

Loss function:- The generator will try to minimize this below loss function while the discriminator will try to maximize it.

For the generator, minimizing the loss is identical to minimizing log(1 — D(G(z)) because the generator cannot directly influence the log(D(x)) term in the function.

In the case of Deepfakes, the Generator is provided with some random input and it processes it to create new images of people(which may not be real). The Discriminator will then try to determine whether the image generated by Generator is a real image or a deepfake image.

In the above image, even though it looks realistic, none of these people exist. These images are deepfakes.

Let’s see some more examples of GANs.

In the above set of images, the ones highlighted in yellow are generated by GANs whereas the non-highlighted ones are the real images. The model is trained on a set of images and it produces new images as output. We can see that it is difficult to determine whether the new images generated by the generator are real or fake for the naked eye.

In some cases, simple GANs, also known as Vanilla GANs, may not completely serve the purpose. So, there are different variations available in GANs to achieve better results.

The different types of GANs are:-

1. Progressive GAN

Only low-resolution images can be produced using traditional GAN-based approaches. Therefore, the progressive GAN is suggested to improve training quality and produce huge images. Progressive GAN naturally extracts the image’s structure utilizing lower layers before focusing on the image’s features. Consequently, images with low resolution are initially created during training, and later their resolutions are raised by the addition of more layers.

2. Conditional GANs

Conditional GANs let you to provide the label for each produced instance and train on a labeled data set. For instance, a conditional MNIST GAN allows you to choose which digit the GAN should create rather than producing random numbers like an unconditional MNIST GAN would.

Conditional GANs simulate the conditional probability P(X | Y) rather than the joint probability P(X, Y).

3. Deep Convolutional GANs

In order to create its discriminator and generator models, the DC-GAN model uses deep CNN(Convolutional Neural Network). This arrangement essentially employs CNNs in the Generator-Discriminator framework to produce images from noisy data that fall under a particular distribution. While DC-GANs exhibit that they are a strong choice for unsupervised learning, they do have some architectural limitations.

4. CycleGAN

CycleGANs acquire the ability to change images from one set into images that could perhaps come from a different collection. In order to enable training without the necessity for paired data, CycleGAN implements a cycle consistency loss. As a result, it is possible to translate across different domains without there being a one-to-one mapping between the source and target domains.

The CycleGAN model contains two mapping functions G:X→Y and F:Y→X, and associated adversarial discriminators Dy and Dx. Dy encourages G to translate X into outputs indistinguishable from domain Y, and vice versa for Dx, F, and X. There are two cycle consistency losses that encapsulate the idea that if we translate from one domain to the other and back again, we should end up where we started in order to further regularize the mappings.

Forward cycle-consistency loss: x→G(x)→F(G(x))≈x

Backward cycle-consistency loss: y→F(y)→G(F(y))≈y

You can try implementing CycleGAN by using the code from TensorFlow. Following is the link for the same:- Run in Google Colab

5. Image-to-Image Translation

Image-to-Image translation GANs take an image as input and map it to a generated output image with different properties.

In the above images, we can see the results of Image-to-Image Translation. In the first case, we try to translate the input image from day → night. In the second case, we try to translate the sketches of handbags → photorealistic handbags.

6. Text-to-image GANs

A deep learning model called Text-to-Image Generative Adversarial Networks (GAN) can generate images from text descriptions. There are different methods available for this. One of them is using StackGAN which generates 256×256 photo-realistic images conditioned on text descriptions. Based on the provided written description, the Stage-I GAN sketches the basic shape and colors of the object, producing Stage-I low-resolution pictures. The Stage-II GAN creates high-resolution images with photorealistic features using the Stage-I results and text descriptions as inputs. Using the refinement process, it is able to fix flaws in Stage-I results and add interesting details.

In the above image, in (a) low resolution image is generated based on the text description. In (b) high resolution image with photo realistic details is generated.

Applications of GANs:

1. Deepfakes
2. Text-to-image synthesis
3. Image-to-image translation
4. Generate Cartoon Characters
5. Photos to Emojis
6. Face Aging
7. Photo Inpainting
8. Video Prediction
9. 3D object generation
10. Generate new human poses

In one of my projects, I have used CycleGAN for Multi-Collection Style Transfer. Style transfer is the process of redrawing or generating a new image that combines the content or scene from one image and the artistic style from a different image or a collection of images. One of the disadvantages of CycleGAN is that you cannot transfer more than one style at a time on an image. I tried some variations in CycleGAN by referring the paper “Gated-GAN: Adversarial Gated Networks for Multi-Collection Style Transfer”. In this paper, they have used another variation of GAN i.e. Gated-GAN. I tried to apply similar logic but using CycleGAN.

Below is the github link for my project:-

GitHub - kajolshah310/Style_transfer_using_CycleGAN: Multi-collection Style Transfer Using CycleGAN

Conclusion:

In this blog, we have learnt about GANs and different variations of GANs which are highly used in Computer Vision problems. I will continue to explore some other CV techniques in my next blog. If you find any mistakes in my blog or have any suggestions, please feel free to let me know about it.

You can subscribe to get an email whenever I post or follow me to read more of my blogs in future.

References:

1. “Generative Adversarial Networks” by I. J. Goodfellow https://arxiv.org/pdf/1406.2661v1.pdf
2. https://developers.google.com/machine-learning/gan
3. https://www.cs.cmu.edu/~epxing/Class/10708-20/scribe/lec13_scribe.pdf
4. Tero Karras, Timo Aila, Samuli Laine, and Jaakko Lehtinen. “Progressive growing of GANs for improved quality, stability, and variation”. In International Conference on Learning Representations, 2018. https://arxiv.org/pdf/1710.10196.pdf
5. “Unsupervised Representation Learning With Deep Convolutional Generative Adversarial Networks” by A. Racford https://arxiv.org/abs/1511.06434
6. “Unpaired Image-to-Image Translation using Cycle-Consistent Adversarial Networks” by J. Zhu https://www.arxiv-vanity.com/papers/1703.10593/
7. “Image-to-Image Translation with Conditional Adversarial Networks” by Phillip Isola https://arxiv.org/pdf/1611.07004.pdf
8. “StackGAN: Text to Photo-realistic Image Synthesis with Stacked Generative Adversarial Networks” by H. Zhang https://arxiv.org/pdf/1612.03242.pdf

We will be using the OpenCV library for our basic image processing. You can try to implement all the functions yourself by using the code blocks provided in this blog.

But what is OpenCV?

OpenCV is an open source C/C++ library with Python wrappers which is used for implementation of standard computer vision algorithms. It can be used to read, write and capture images or videos in various formats as well as perform image processing techniques like filtering, edge detection, corner detection, etc.

There are two Python wrapper versions of OpenCV available:-

cv (older, non python standard image storage)

• cv2 (contains cv, uses numpy n-dimensional arrays)

We will use cv2 wrapper version for our implementation.

To install OpenCV python package, you can enter either of the below commands in terminal:-

pip install opencv-python or

pip3 install opencv-python

Now, let’s start our implementation by first importing the necessary libraries.

import cv2
import numpy as np
import sys
from PIL import Image
import matplotlib.pyplot as plt

To read the images, we will use the imread() function in opencv.

filename = "friends.jpeg" # file path
image = cv2.imread(filename)
print(image.shape)  # shape of the image

# Output:
# (400, 700, 3)

To obtain image size, we use image.shape. A color image is a 3D n-dimensional array of (rows * columns * colors) i.e. (height * width * number of color channels). For a color image, the number of color channels will be 3 based on the RGB color model.

eg. shape of image:- (400, 700, 3)

The RGB color model is an additive color model in which the red, green and blue primary colors of light are added together in various ways to reproduce a broad array of colors.

To capture a live image from our webcam, we will use the cv2.VideoCapture() function.

cap = cv2.VideoCapture(0) 
retval, image = cap.read()

To resize an image, we will use the cv2.resize() function

resize_im = cv2.resize(image,(800,600))
print(resize_im.shape)

# Output:
# (600, 800, 3)

To display an image, we will use the cv2.imshow() function

cv2.imshow('Original image',image) # 'Original image' is the title of the image window 
cv2.waitKey(0)
cv2.destroyAllWindows()

Here, the cv2.waitkey() function lets us display a window for the specified number of milliseconds and if 0 is passed, it will wait forever until any key is pressed. The cv2.destroyAllWindows() function will close or destroy all the image windows. To stop or close the image window, press any key.

Output:

To convert an RGB image to greyscale, we will use the cv2.cvtColor() function which is used to convert an image from one color space to another. cv2.COLOR_BGR2GRAY color conversion method will convert the image to grayscale. Here, the image will be converted from 3 dimensions to 2 dimensions.

gimage = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
cv2.imshow('Grayscale',gimage)
cv2.waitKey(0)
cv2.destroyAllWindows()
print(gimage.shape)

#Output:
#(400, 700)

Output:

Below are the ways to convert RGB image to grayscale without using in-built OpenCV functions:-

grayimage = np.dot(image[...,:3],[0.299, 0.587, 0.114])
cv2.imshow('Grayscale without OpenCV',gimage)
cv2.waitKey(0)
cv2.destroyAllWindows()
print(grayimage.shape)

#Output:
#(400, 700)

Output:-

Another way by using loops and Python Imaging Library(PIL):

arr = np.array(image)
for i in range(len(arr)):
    for j in range(len(arr[i])):
        b = arr[i, j, 0]
        g = arr[i, j, 1]
        r = arr[i, j, 2]
        grayimage = b * 0.114 + g * 0.587 + r * 0.299
        arr[i, j] = grayimage
Image.fromarray(arr).show()

Output:-

To rotate an image from 0 to 360 degrees, we can use the getRotationMatrix2D() function which will create the transformation rotation matrix. The cv2.warpAffine() function will apply the transformation on the image. The cv2.createTrackbar() function will help us to change the angle of rotation of our image.

def sliderHandler(theta):
    rows = image.shape[0]
    cols = image.shape[1]
    M = cv2.getRotationMatrix2D((cols/2, rows/2), theta, 1)
    dst = cv2.warpAffine(image, M, (cols, rows))
    cv2.imshow(winName, dst)

cv2.namedWindow("RotationWindow")
winName = "RotationWindow"
cv2.createTrackbar('r', "RotationWindow", 0, 360, sliderHandler)   
cv2.imshow("RotationWindow", image)
cv2.waitKey(0)
cv2.destroyAllWindows()

Output:-

Now, we will see how to cycle through the color channels of the image. For this, we will take an image in which we can clearly see the RGB colors distinctly.

We will use the cv2.split() function to separate the colored multi-channel image into single-channel images i.e. into Red, Blue and Green channels.

filename2 = "rgb01.png"
image = cv2.imread(filename2)
b, g, r = cv2.split(image)
cv2.imshow("Blue", b)
cv2.waitKey(0)
cv2.destroyAllWindows()
print(b.shape)

#Output:
#(316, 314, 3) -  image shape before using split function
#(316, 314) - after using split function

The shape of the image before split is 3D and after split becomes 2D.

Output of blue channel:-

We can see that as the channel is blue, the intensity of blue color in the image is very high.

cv2.imshow("Green", g)
cv2.waitKey(0)
cv2.destroyAllWindows()
print(g.shape)

#Output:
#(316, 314)

Output of green channel:-

We can see that as the channel is green, the intensity of green color in the image is very high.

cv2.imshow("Red", r)
cv2.waitKey(0)
cv2.destroyAllWindows()
print(r.shape)

#Output:
#(316, 314)

Output of red channel:-

Let’s take another image example to see the proper outputs of our functions.

We will now see how to implement image blurring i.e. image smoothing. For this, we will convolve the image with a low-pass filter. Smoothing is used to remove noise and high frequency content(eg. edges, corners, etc) from the image. There are different ways by which we can achieve smoothing. First is by using cv2.filter2D() function.

kernel = np.ones((5,5),np.float32)/25 #using a 5x5 filter
dst = cv2.filter2D(image,-1,kernel)
cv2.imshow('Smoothing using filter2D', dst)
cv2.waitKey(0)
cv2.destroyAllWindows()

Output:-

Let’s see how to implement smoothing by keeping the kernel size variable. Here, we will first convert the image to grayscale and then implement variable smoothing.

def sliderHandler1(n):   
    image = cv2.imread(filename3)
    gimage = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
    kernel = np.ones((n,n),np.float32)/(n*n)    #make a smoothing filter
    sm = cv2.filter2D(gimage, -1, kernel)    #convolve
    cv2.imshow(winName, sm)
winName = 'Smoothing'
cv2.imshow(winName, image)
cv2.createTrackbar('s',winName, 0, 255, sliderHandler1) #slider bar [0, 255]
cv2.waitKey(0)
cv2.destroyAllWindows()

Output:-

Now we will see how to upsample or upscale an image i.e. increase its spatial resolution by a factor of 2. One way to do this is using the cv2.resize() function which we have already used above. Another way is using cv2.pyrUp() function.

print(image.shape) #before upscaling
uimage = cv2.pyrUp(image)
cv2.imshow('Upscaling',uimage)
cv2.waitKey(0)
cv2.destroyAllWindows()
print(uimage.shape) #after upscaling

#Output:

#(159, 318, 3) #image size before upscaling
#(318, 636, 3) #image size after upscaling

Output:-

Next, we will see how to downsample or downscale an image i.e. decrease its spatial resolution by a factor of 2 using cv2.pyrDown()

print(image.shape) #before downscaling
dimage = cv2.pyrDown(image)
cv2.imshow('Downscaling',dimage)
cv2.waitKey(0)
cv2.destroyAllWindows()
print(dimage.shape) #after downscaling

#Output:
#(159, 318, 3) #image size before downscaling
#(80, 159, 3) #image size after downscaling

Output:-

To detect the corners in an image, we will use cv2.cornerHarris() function. We will handle the number of corners detected in the image by increasing or decreasing the threshold value.

def sliderHandler1(n2):    
    global imagec
    n2 = n2*0.01
    imagec = np.float32(image3)    #make a smoothing filter
    dst = cv2.cornerHarris(imagec, 2, 3, n2) 
    dst = cv2.dilate(dst, None)
    imagec=cv2.merge((image3, image3, image3))
    threshold = 0.01*dst.max() #threshold value for detecting the corners
    imagec[dst>threshold]=[0,0,255]
    cv2.imshow(winName2,imagec)

winName2 = 'corner detection'       
image = cv2.imread(filename3)
image3 = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
cv2.imshow(winName2, image3)
cv2.createTrackbar('c',winName2, 0, 100, sliderHandler1) #slider bar to handle number of corners
cv2.waitKey(0)
cv2.destroyAllWindows()

In the above output, we can see that if the threshold value is low, more corners will be detected and if it is high, less corners will be detected.

We will try corner detection on another image where we can see corners clearly.

Output:-

Conclusion: In this blog, we have learnt about the different image processing techniques in Computer Vision. I will continue to explore some other CV techniques in my next blog. If you find any mistakes in my blog or have any suggestions, please feel free to let me know about it.

You can subscribe to get an email whenever I post or follow me to read more of my blogs in future.

You can find the code for the implementation here:- https://github.com/kajolshah310/basic_image_transformations_in_CV

References:

https://docs.opencv.org/4.x/

Computer Vision is a sub-area of AI which enables computers to analyze images or videos and extract meaningful information from them, mimicking human vision. Some of the applications of CV are face recognition, self driving cars, object detection, etc.

When we click a picture, a real scenario which is in 3D is captured by a real camera in 2D. So here, 3D to 2D conversion takes place which means we have lost information about a dimension. This is where computer vision enters the scene. Using CV, we can try to recover the missing information, or you can say, a missing dimension and gain high level understanding of the image.

Real Scene (3D) → Real Cameras (2D) → CV Output (3D)

Now, let’s understand the basics of CV. For this, we need to first understand about image formation. Below, we will see how images are formed using Geometric Camera models.

Pinhole Camera Model

Before lenses came into existence, pinholes were used to capture images. World’s first camera model was invented using this model. For a pinhole camera, a hole of the size of a pin is created on one side of a box and a thin paper on the other side of the box. The light entering this hole will then project the image of the world on the paper. The image captured will be upside down i.e. an inverted image. Below is the example of an image captured by a pinhole camera.

In this above image, we can see that a real world 3D object tree’s inverted 2D image is formed by using a pinhole camera model.

Now, let’s understand some basic notations for image formation.

f → distance between the image and the screen (in pinhole camera) and in terms of lens camera, focal length

z → distance of the object from the screen

(x, y, z) → real 3D world coordinates

(u, v) → 2D image coordinates

• Bigger the focal length (f), bigger will be the image
• Ratio of both the triangles will be the same and will have the same angle
• Size of image (u, v) is directly proportional to f. So, bigger the focal length(f), bigger the image
• Size of image (u, v) is inversely proportional to z. So, the further the object, the smaller it will appear on the image plane
• As the image formed is inverted, the pinhole perspective projective equations will have a negative sign

Pinhole Perspective projection equations:-

In matrix form:-

Alternative Pinhole Camera Model

Without inversion, based on triangle similarity, the equations will be:-

Both models are the same with just a sign difference.

To get rid of z and to get linear equations, we will convert the cartesian coordinates to homogeneous coordinates.

2D → 2DH

(x, y) → (x, y, 1)

Moving from 2DH to 2D:-

(x/w, y/w) ← → (x, y, w) where w is a homogeneous component.

Perspective projection equation in Homogeneous coordinates:-

3D to 2DH matrix equation is not balanced. Below is the balanced matrix representation of pinhole model from 3DH to 2DH:-

As we have added 1 to the 3D coordinates, we add a column of zeros to the projection matrix to balance the equation.

A final word

Computer Vision is a vast and complex field but to learn anything, we need to take baby steps. I will be continuing with the basics of CV in my future blogs.

You can subscribe to get an email whenever I post or follow me to read more of my blogs in future.

References:-

• Computer Vision — A Modern Approach — D. Forsyth, J. Ponce
• Lecture notes of Professor Gady Agam, Illinois Institute of Technology

Well, there are two possible solutions for this. One — going by the traditional method and reading all the documents which may result in you wasting too much time on insignificant content. A better solution — using a text summarizer.

Text Summarizer — A tool which generates a condensed version of the original document

But how do you create a Text Summarizer?

In this blog, we will see how to develop a query oriented extractive Text Summarizer using Unsupervised Deep Learning techniques. The term query oriented here means the summary will be generated according to the query/ topic entered by the users as per their interests. This can be best implemented using Python as it provides an extensive set of libraries like Pdfminer, NLTK, NumPy, etc. that have functions which can be used for our process.

Extractive text summarization — In this method, sentences are directly picked from the document based on some features to form a brief summary

Unsupervised learning — where a machine learns and looks for patterns in a dataset having no labels or outcomes

Deep learning — this type of learning involves multiple processing layers to extract features from data

Steps to create a Text Summarizer

A] Input — In the first step, the user will give a single PDF or a text document they want to summarize as input. Read the contents of this file and store it in a variable.

B] Pre-processing — In this step, the words which are not important are removed in order to structure the document and reduce its density. This makes the further processing of the document easier. The four techniques used are:-

1. Stop-word removal — Stop-words i.e. words which are not important and don’t have any meaning on their own are filtered in this step. Usually articles, prepositions, etc. are considered as stop words and are removed. Here, we have considered words such as a, an, the, is, are, on, etc. as stop-words. NLTK corpus provides you with a bunch of stops words and using this set, you can remove these stop-words from your text.
2. Part of Speech Tagging — Categorizing the words of text on the basis of part of speech (noun, adverb, verb, adjective etc.) is called as Part of Speech Tagging. So, in this step, the words are marked corresponding to a part of speech.
3. Stemming — In this step, all the words are brought to their base or root form except for the words which belong to the proper nouns category. Example: the word ‘boys’ reduced to ‘boy’, ‘swimming’ reduced to ‘swim’. It will not always be the case that the stemmed word would be the same as the root form of the word.
4. Punctuation marks removal — The punctuation marks like “, . : ; ? / “ etc from the document are removed in this step, hence making the document light-weight and further simplifying the summary generation process.

The NLTK library provides functions which can be used to execute the above pre-processing techniques.

C] Feature Vector extraction — The document which is made light weight in the pre-processing phase is now structured into a matrix. A sentence matrix ‘M’ of order n*v contains the features for every sentence of a matrix. Here, ‘n’ is the number of sentences in the document and ‘v’ is the number of features. The five features that we will be considering are:-

1. Title Similarity — A sentence in the document is said to be important for the summary if it is similar to title of the document. The title similarity is calculated using the sentence score which is defined as the ratio of number of common words occurring between the title and the sentences in the document to the total number of words of the document. The feature sentence of a sentence is said to be good if it has maximum number of words common to the title.

2. Sentence Position — The position of the sentence can determine the relevance of the sentence for the summary. Usually the sentences that appear in the starting and ending of the text are of more importance. So, based on this the sentence score is calculated. The positional score in our case is calculated by considering the following conditions:-

Here, we have considered 20% of sentences from the start and the end of the text as important and marked their p2 value as 1.

3. Term Weight — Term weight means the term frequency and its importance. The term frequency(tf) gives the total number of times the term has occurred in the whole document which depicts the importance of the term in a document. The inverse sentence frequency(isf) tells whether the term is common or rare across the document.

4. Sentence Length — The sentence length decides the importance of the sentence in summarization. The sentences that are too short do not give much information about the document. Whereas sentences that are too long will have unnecessary information about the document that will not be useful for summarization.

5. Proper Noun Score — In the process of summary generation, important role is played by the Proper Nouns. It gives information regarding, to whom or to what the author is referring. Roles played by individuals or description of locations will be different more number of times in a document. Here, the number of words which are proper nouns are counted.

D] Feature Matrix Generation — The above calculated features’ values are then stored in a matrix form where the columns represent the features and rows represent the sentences.

E] Algorithm for Deep Learning — Here, we are using Restricted Boltzmann Machine(RBM) for deep learning. The sentence matrix containing a set of feature vectors is given as an input to the RBM phase as a visible layer.

F] Enhanced Feature Matrix — An Enhanced feature matrix is obtained from the deep learning phase which is used for the further summary generation phase.

G] Generation of Summary — Summary can be generated in two ways. One is a generalized summary of the whole document and the other way is based on the user query entered by the user.

1. Sentence score — This step is performed only for user-query based summary generation. Here, the ratio of the number of words which are common in the sentence and the query entered by the user to the total number of words in the document are calculated.

2. Sentence ranking — The number of sentences which should be there in the summary is calculated by

N=0.3* total number of sentences in the text

Here, we are considering 30% of the sentences in the document for the summary. You can change this numeric value if you want a more shorter or longer summary.

Sentence ranking for generalized summary: The sum of the feature values for each sentence in the enhanced matrix is calculated. Now based on these values, the sentences are arranged in descending order(sentences having higher feature sum). Now, the top N sentences are selected from this sorted order of sentences.

Sentence ranking for user-query based summary: Here, based on the sentence score, sentences are arranged in descending order. Now, the top N sentences are selected from this sorted order of sentences.

3. Summary generation — The N sentences selected are now arranged according to their position in the text and then displayed to the user. In this way, extractive summary is generated.

The summary produced by the above text summarization method using unsupervised deep learning algorithm is better than the summary produced by methods using supervised learning techniques as no training data-set is required in the proposed approach. Hence, the time and cost required to train the data-set is saved. So, this method is more efficient.

You can also develop a GUI for this tool using Python package Tkinter. Below is a basic sample GUI developed by me using Tkinter.

Future Applications:- This method can be further improved for generating summaries of books of large volumes. Also, we can add some features to this summarization method to generate user-query based summary of medical reports. Researchers can use this tool to generate summaries of their papers and anyone can use it to summarize any books or papers.

Conclusion

In this blog, we have seen how we can reduce our burden of reading as well as analyzing bulk and bulk of documents by creating a smart tool called Text Summarizer. We have seen a few applications of this tool in this blog and you can also let me know your ideas on this.

References

M Yousefi-Azar, ”Text Summarization using unsupervised deep learning”, Science Direct, Volume:68, 2017, Page:93–105

PadmaPriya G. and 2K. Duraiswamy , ”An Approach for Text Summarization using deep learning approach”, Journal of Computer Science, Volume:10, 2014, Page:1–9