Bodo Language Text Summarization Using Lstm Encoder-Decoder

doi:10.21203/rs.3.rs-4841414/v1

Download PDF

Research Article

Bodo Language Text Summarization Using Lstm Encoder-Decoder

https://doi.org/10.21203/rs.3.rs-4841414/v1

This work is licensed under a CC BY 4.0 License

Version 1

posted

You are reading this latest preprint version

This study specifically targets text summarization for the Bodo language, which is widely spoken in northeastern Indian states such as Assam and West Bengal, as well as in some areas of Nepal and Bhutan.The specific difficulties of Bodo text summarization is handled by using an LSTM Encoder-Decoder system. By conducting thorough testing and assessment, the efficacy of the technique in generating top-notch summaries that accurately capture the substance of the original Bodo text. Remarkably, this research is pioneering as it fills the gap of previous work in Bodo text summarization, marking the first systematic attempt in this domain and achieving an impressive accuracy rate of 81%. Furthermore, this research explores the complexities of the Bodo language and its cultural importance in the northeastern area of India. We investigate the Bodo language and cultural traditions, with a focus on their influence on the social and economic environment of Assam and surrounding regions. By illuminating the socio-cultural environment in which the Bodo language exists, we emphasize the significance of safeguarding it and guaranteeing convenient availability of information in communities with many languages.The proposed study aims to support the promotion of linguistic variety and the preservation of cultural heritage. The objective is to improve inclusiveness and accessibility to information for speakers of marginalized languages such as Bodo, thereby facilitating the flow of knowledge and ideas across different languages.

Bodo language

Text summarization

LSTM Encoder-Decoder

Indigenous languages

Cultural heritage preservation

Bodo, an indigenous language closely intertwined with the socio-cultural fabric of Assam and nearby regions, plays a vital role in safeguarding the cultural heritage of the Bodo population. Nevertheless, Bodo, like numerous other indigenous languages, encounters obstacles pertaining to the preservation, accessibility, and digitization of language in the digital age, despite its cultural importance.

Text summarization is a crucial tool in the field of natural language processing (NLP) for condensing extensive amount of text into brief and informative summaries. Text summarization has mainly two approaches: Abstractive text summarization and Extractive text summarization. Abstractive text summarization involves generating summaries that may contain new sentences not present in the original text but convey the same meaning. On the other hand, extractive text summarization involves selecting and rearranging existing sentences from the original text to create a concise summary.

This research work presents a novel method of extractive text summarizationfor Bodo text by utilizing an LSTM (Long Short-Term Memory) Encoder-Decoder architecture. LSTM networks, a kind of recurrent neural network (RNN), are highly suitable for tasks involving sequential data processing, such as text summarization, since they possess the capability to collect long-range dependencies and context information. The decision to use the LSTM Encoder-Decoder architecture is based on its efficacy in modeling sequential data and capturing semantic information over various sections of the input text. Within the suggested architecture, the encoder component considers the input Bodo text and transforms it into a vector representation of a consistent length. This vector representation effectively captures the semantic content of the text. The decoder component uses the encoded representation to provide a summary by anticipating the most pertinent words or phrases. The methodology utilizes LSTM networks to generate precise and contextually appropriate summaries that maintain the core meaning of the original Bodo text.

By conducting thorough experimentation and evaluation, we prove the effectiveness of the approach in generating top-notch summaries that meet the specific requirements of Bodo speakers. This research delves into the socio-cultural framework that surrounds the Bodo language and its influence on the socio-economic environment of northeastern part of India. By tackling the difficulties of Bodo text summarization and utilizing the advantages of LSTM Encoder-Decoder architecture, we not only enhance the ease of accessing information for Bodo speakers but also support the conservation and advancement of indigenous languages in the digital era.

The efforts are focused on empowering Bodo communities, fostering language variety, and promoting the preservation of cultural legacy in the northeastern part of India and beyond.

"An Automatic Text Summarization for Malayalam Using Sentence Extraction" by Renjith S R et al. is a research paper that describes a new way to extract and summarize text in Malayalam [1]. Five different steps in the method are explained and each one helps to make short, useful outlines. Steps in the process as mentioned are Preprocessing, Sentence Scoring, and Finding Similarity between Sentences, Ranking Sentences, and Making a Summary.

In the paper, "Complete Pre Processing Phase of Punjabi Text Extractive Summarization System," Vishal Gupta summed up text in Punjabi in 2010 and 2012, as shown in two separate studies. The extraction method was used to summarize both news stories and other types of texts [2]. There are two key steps to summarize news stories: pre-processing and processing. On the other hand, the TF-IDF method was used to summarize the text.

"Information Retrieval by Text Summarization for an Indian Regional Language" by Jagadish S Kallimani, Srinivasa K G, and Eswara Reddy B is a study paper that describes a text summarization method that is specially made for the Kannada language. This method was created based on the features of a program called AutoSum that summarizes. The method starts by reading a written piece that has been encoded in UTF-8 format. A vocabulary or tagging and analyzing the text are both ways to get the keywords out of the text. After that, lines are judged on a number of factors, including where they appear, how often they appear in the first line, their numerical value, and their relationship to the keywords that are pulled. The final report is made by choosing words based on how highly they are ranked, which effectively condenses all the information[3].

In their paper "Automatic Keyword Extraction from Dravidian Language", M. Hanuman Thappa, M. Narayana Swamy, and N. M. Jyothi describe a way to get keywords out of Dravidian languages like Tamil. Tokenization, an important step in natural language processing, is the first step in the process. Breaking the text into separate tokens, or words, is what tokenization does. Once the text has been tokenized, stop word removal is used to get rid of common words that don't have much meaning. This leaves behind a list of vocabulary words[4].

The authors of "Marathi e-Newspaper Text Summarization Using Automatic Keyword Extraction Technique" (ShubhamBhosale, Diksha Joshi, VrushaliBhise, and Rushali A. Deshmukh) created a program that can automatically pull keywords from Marathi e-newspapers for their study [5]. The Word Extraction Module and the Summarization Module are the two main parts of the method. A story from an e-newspaper is fed into the system's Word Extraction Module. After the piece is tokenized, any stop words are taken out. The steps in this process produce the keywords, which are then ranked by how important they are. In the Summarization Module, lines that have the buzzwords that were found are picked out and given a score. The top lines, which make up 10–40% of the original text, are the only ones that are shown.

"Test Model for Representation Rich for Semantic Hindi Text Graph using Abstractive Method" by ManjulaSubramaniam and VipulDalal (2015) used an abstractive method with advanced semantic graph techniques for the text summarization [6].

The authors M. HumeraKhanam and S. Srivanani in the paper “Text Summarization for Telugu Document"have showed how to use a frequency-based method to create a summary technique that works well for Telugu texts. To start the process, the raw text is tokenized, which means it is broken up into single words, or tokens. After that, stop words like adjectives and conjunctions are taken out of the text. After that, the frequency of each word that is still there is found. Sentences with words that are used a lot are taken out and put into the end report. This plan tries to make the paper shorter by giving more weight to key words that show up a lot in the text[7].

In the paper "Bhasa: A Corpus-Based Information Retrieval and Summarizer for Bengali Text" Md. Tawhidul Islam and Shaikh Mostafa Al Masum introduced Bhasa, an innovative tool designed for Bengali text analysis. Bhasa is a corpus-based search engine and summarizer, leveraging advanced techniques for document indexing and information retrieval. It includes a vector space retrieval method to efficiently process user queries and deliver desire results [8].

In the paper "Bengali text summarization by sentence extraction" the author Kamal Sarkar used the harvesting approach and TF-IDF algorithms [9].

In the paper "Topic Based Bengali Opinion Summarization" Amitava Das and Sivaji Bandyopadhyayused the harvesting method, which included the k-means algorithm and the page rank standard method [10].

"An Extractive Approach of Text Summarization of Assamese Using WordNet" by Chandan Kalita, Navanath Saharia, and Utpal Sharma describe a text summary method that is especially useful for Assamese works [11]. The method has three key parts: preprocessing, guessing how many groups there are, and making a summary. Assamese WordNet is used to figure out how semantically close two words are during the preprocessing step. A resemblance function is also used to find out how similar two sentences are in terms of structure and meaning. Moving on to the next step, they figure out how many groups there are by looking at how many themes are in the text. The writers use the K-means method to group the words together so that a summary can be made. Then, they pick the most important lines from each group. After that, they figure out how much the unselected words match up with the title of the paper. Sentences that sound like the title have been taken out. At end, the words are put into groups based on how often they appear in the input and are shown in the summary.

"Query–Based Extractive Text Summarization for Sanskrit" by Siddhi Barve, Shaba Desai, and RaziaSardinha is a study that describes a query-based method for summarizing texts that is especially made for Sanskrit[12]. There are three main parts to the system: preparation, sentence extraction, and grading. Both very short and very long words are taken out of the text by the preprocessing tool. First, the text is tokenized, and then stop words are taken out. The words are broken down into their parts, and each one is put into one of two groups: compounds and sandhis. In sentence extraction, there are three ways to get the words out. Some of the methods used are Average TF-ISF, vector space model, and graph-based approach with PageRank. Using a query and these three methods together will give you sentences that answer the question. A question could be any word that is not broken up. At end, the sentences with the highest scores are picked to make the summary. The vector space model and PageRank did better than the average TF-ISF after being looked at.

The authors Jikitsha Sheth and Bankim Patel "Saaraansh: Gujarati Text Summarization System" [13] made a text summarizer called Saaraansh that is especially for Gujarati text The major contribution of the work is Dhiya stemmer, a GujStringSimilarity module, a stem weightage module, a LexRank module, an anaphora resolver, and a sentence generator. The writing is broken up into words, and each phrase has its own number. The text is broken up into separate lines, and words that are used a lot but don't mean much are found and removed. The GujStringSimilarity tool figures out how similar two words are in terms of their meaning. The words are put into a standard style, and then the Gujarati stemmer, Dhiya is used to look at them. In the weightage section of STEM, the TF-IDF for each line is found. The cosine relationship between two sentences is found by the LexRank module. It is possible to make a graph where an edge between two nodes shows how alike they are. The LexRank algorithm sorts the words in the graph and pulls out the ones that belong in the summary. The anaphora resolution is done by comparing the shortened text to the original. In turn, this makes the process of choosing words for the summary better.

An intelligent decision is made when deciding on the Long Short-Term Memory (LSTM) Encoder-Decoder architecture, which aims to reduce massive amount of text into brief summaries, interpreting the inherent complexity of summarizing and interpreting natural language. The method can handle variable-length sequences and still capture the subtle correlations seen in text data. With its capacity to simulate long-term relationships and alleviate the vanishing gradient issue that classic recurrent neural networks frequently face, LSTM became an attractive option. The objective of the work is to utilize deep learning capabilities by employing LSTM units in an Encoder-Decoder system to produce precise and educational summaries from unprocessed text inputs automatically. The demonstrated effectiveness of LSTM-based architectures across a range of sequence-to-sequence tasks, such as text production, speech recognition, and machine translation, served as additional justification for this choice. Consequently, the choice of the LSTM Encoder-Decoder architecture is a conscious attempt to apply state-of-the-art neural network methods to the difficult problem of text summarization.

Long Short-Term Memory (LSTM)

Recurrent neural network (RNN) architecture known as Long Short-Term Memory (LSTM) was developed in order to solve the vanishing gradient issue that conventional RNNs have. Because LSTMs are made to store information over longer time steps than regular RNNs, they are well-suited for jobs involving text, voice, and time-series data, whereas standard RNNs have trouble capturing long-range relationships in sequential data. The foundation of LSTMs is the insertion of specialized memory cells, which enable them to accurately simulate long-term relationships by selectively retaining or discarding information at each time step.

The LSTM cell is made up of the following:

The Input gate ($\:{i}_{t}$) regulates the amount of fresh data that enters the cell state and is mathematically indicated by Eq. (1).The Forget Gate($\:{f}_{t}$) function selects that data from the previous cell state that needs to be ignored, and is represented by Eq. (2).Output Gate ($\:{o}_{t}$) adjusts the output according to the condition of the cell at that moment, and is represented by Eq. (3).

Candidate Cell State ($\:{g}_{t}$) represents the new candidate values that could potentially be added to the cell state at the current time step, that can be mathematically indicated by Eq. (4).

Cell State($\:{C}_{t}$) is a representation of the cell's internal memory, which is able to be changed or preserved over time,that can be mathematically indicated by Eq. (5).

Hidden State($\:{h}_{t}$) stores the pertinent data to be sent to downstream layers or later time steps, that can be mathematically indicated by Eq. (6).

The calculations carried out by an LSTM cell can be stated mathematically as follows:

$$\:{f}_{t}=\sigma\:({W}_{f}.\left[{h}_{t-1},{x}_{t}\right]+{b}_{f})$$

$$\:{i}_{t}=\sigma\:({W}_{i}.\left[{h}_{t-1},{x}_{t}\right]+{b}_{i})$$

$$\:{O}_{t}=\sigma\:({W}_{o}.\left[{h}_{t-1},{x}_{t}\right]+{b}_{o})$$

$$\:{g}_{t}=tanh({W}_{c}.\left[{h}_{t},{x}_{t}\right]+{b}_{c})$$

$$\:{C}_{t}={f}_{t}\odot\:{c}_{t-1}+{i}_{t}\odot\:{g}_{t}$$

$$\:{h}_{t}={o}_{t}\odot\:\text{t}\text{a}\text{n}\text{h}\left({c}_{t}\right)$$

W_f, W_i, W_o and W_c are weight matrices associated with the forget gate, input gate, output gate, and cell state calculations, respectively.

b_f, b_i, b_o and b_c are bias terms specific to the forget gate, input gate, output gate, and cell state calculations, respectively.

Encoder-Decoder Architecture

The working principle is based on the sequence-to-sequence activity. There are two primary parts to it: an encoder and a decoder. The encoder extracts the important information from the input sequence by processing it and encoding it into a fixed-length vector representation. After obtaining this representation, the decoder uses the encoded input as a condition to gradually produce the output sequence. When it comes to text summarizing, the decoder creates the relevant summary, and the encoder gets the input material. The final hidden state of the encoder becomes the decoder's starting hidden state, enabling the latter to utilize the encoded data to provide a succinct summary.

The encoding procedure is mathematically summed up as stated in Eq. (7).

$\:{h}^{enc}=Encoder\left(x\right)$ ---------------------------(7)

Each token in the output sequence is created throughout the decoding process using the encoder's secret states and previously generated tokens as a basis:

$\:{h}_{0}^{dec}=InitialHiddenState\left({h}^{enc}\right)$ ----------(8)

$$\:y1=Decoder({h}_{0}^{dec},<start>)$$

$$\:y2=Decoder({h}_{1}^{dec},y1)$$

. .

$$\:{y}_{t+1}=Decoder({h}_{t}^{dec},yt)$$

Effective methods for modelling sequential data and handling challenging natural language processing problems include LSTM and the encoder-decoder architecture. Through the utilization of LSTMs and the adaptability of the Encoder-Decoder framework, scholars and professionals may create advanced models that can comprehend and produce text summaries that resemble human writing with exceptional precision and fluidity.

The text summarization research seeks to construct a strong model capable of generating brief summaries from news stories published in the Bodo language. The dataset consists of 100 rows taken from several Bodo e-newspapers. The dataset comprises rows that contain titles and their related summaries, offering useful insights into the wide array of topics covered by Bodo publications. By carefully preparing and analyzing data and training models, the goal is to utilize natural language processing to automate the summary process. This will allow users to efficiently understand the main ideas of news items without having to read them in detail. The goal is to develop a model that utilizes advanced techniques like LSTM with an Encoder-Decoder architecture to effectively understand and summarize Bodo news articles with accuracy and timeliness.

5.1.Data Preprocessing:

The application initiates by extracting the data from an Excel spreadsheet that includes titles and summaries. Prior to tokenization, the text undergoes preprocessing to exclude special characters such as punctuation marks and symbols. This initial preprocessing phase guarantees that the text is devoid of any unwanted elements and is prepared for the process of tokenization.

5.2. Tokenization:

After preprocessing, the textis tokenized using the Keras Tokenizer. This process entails the training of the Tokenizer on combined titles and summaries to create a lexicon and allocate distinct numerical identifiers to each token. The preprocessed text is subsequently transformed into token sequences using the texts_to_sequences function of the Tokenizer.

5.3. Padding:

In order to maintain consistency in the length of sequences, the token sequences are extended to a predetermined length by adding padding. Both titles and summaries have a predetermined maximum length. If a sequence is shorter than the maximum length, it is filled with zeros to match the maximum length. The purpose of this padding step is to ready the data for input into the model.

5.4. Splitting Data:

The preprocessed data is split into training and validation sets using the train_test_split function from scikit-learn. The proportion of data allocated for validation, typically 20%, is specified during the splitting process. This split allows for model evaluation and monitoring of generalization performance.

5.5. Creating Dataset and DataLoader:

A custom PyTorch dataset class called TextSummarizationDataset is developed to manage the data within the PyTorch framework. This class facilitates the process of iterating through the dataset and obtaining individual samples. DataLoader objects are instantiated for both the training and validation sets in order to efficiently load the data in batches throughout the training process.

5.6.Model Definition:

The encoder-decoder model's architecture is specified using PyTorch'snn.Moduleclass. The model consists of an embedding layer that converts token IDs into dense vectors, LSTM layers for both the encoder and decoder components, and a fully connected layer that generates output predictions.

5.7. Training Loop:

The model is trained by iterating over a predetermined number of epochs, usually 70 epochs. During each epoch, the software sequentially processes batches of data from the training DataLoader. The loss is calculated using an appropriate loss function, such as CrossEntropyLoss, and the model parameters are updated using backpropagation with the selected optimizer, such as Adam.

5.8. Validation:

In order to assess the model's performance and its capacity to generalize, it is assessed using the validation set. The accuracy metric is determined by comparing the model's predictions with the actual summaries. This process entails iteral through batches of validation data from the validation DataLoader and calculating the correctness.

5.9. Model Saving:

After the completion of training, the state dictionary of the trained model is stored in a file using the torch.save function in PyTorch. The saved model can be subsequently loaded and utilized for inference or additional fine-tuning.

The model utilizes the LSTM (Long Short-Term Memory) Encoder-Decoder architecture, which is a reliable foundation for a range of sequence-to-sequence tasks, such as text summarization. This architectural design consists of two main elements: an encoder and a decoder, both utilizing LSTM (Long Short-Term Memory) units.

Encoder:

The encoder takes the input sequence, typically the source text, and encodes it into a fixed-size representation. This process involves the following steps:

a. Embedding Layer: The input sequence is first passed through an embedding layer, which converts each word into a dense vector representation.

Embedded Input=Embedding Layer(Input Sequence)

b. LSTM Encoder: The embedded input is then fed into the LSTM encoder, which processes the sequence while maintaining information about the sequence context. The encoder produces hidden states and cell states at each time step.

Encoder Output,(Hidden State,Cell State)=LSTM Encoder(Embedded Input)

c. Output: The final hidden state and cell state of the encoder, along with the encoder output, serve as the context vectors that capture the input sequence information

Decoder:

The decoder generates the target sequence based on the encoded information from the encoder. It follows these steps:

a. Embedding Layer: Similar to the encoder, the target sequence (initially filled with start tokens) is passed through an embedding layer to obtain dense vector representations.

Embedded Target=Embedding Layer(Target Sequence)

b. LSTM Decoder: The embedded target sequence, along with the initial hidden and cell states from the encoder, is inputted into the LSTM decoder. The decoder processes the sequence while attending to the encoder's context vectors, producing hidden states and cell states.

Decoder Output,(Hidden State,Cell State)=LSTM Decoder(Embedded Target,Initial States from Encoder)

c. Linear Layer: The decoder output is then passed through a linear layer, which transforms the hidden states into output probabilities.

Output Probabilities=Linear Layer(Decoder Output)

d. Softmax Activation: Finally, a Softmax activation is applied to obtain a probability distribution over the vocabulary for each time step.

Output Distribution=Softmax(Output Probabilities)

The LSTM Encoder-Decoder model efficiently handles input sequences, captures their context, and generates corresponding output sequences by integrating the encoder and decoder components. This architecture is very suitable for tasks such as text summarization, where the length of the input and output sequences may differ and necessitate the comprehension of long-term relationships.

Executing 70 epochs of training forthe LSTM Encoder-Decoder model for text summarization, encouraging outcomes are obtained in terms of accuracy and loss measures. The model attained an accuracy of 81% on the validation set, as illustrated in figure (e), demonstrating its capacity to produce precise summaries for input texts. During the training phase, the validation loss consistently reduced and reached a stable value of 0.050, as shown in figure (d). This indicates that the model successfully converged and efficiently minimized the loss function. Figure (d) illustrates the validation loss, which exhibited a consistent decline throughout the epochs, suggesting that the model had the capacity to acquire knowledge and enhance its performance. Figure (e) illustrates the precision of the model on the validation set, demonstrating a favorable trend that indicates the model's predictions closely match the actual summary.

The selection of 70 epochs was determined by empirical assessment, during which the model's effectiveness consistently enhanced with each epoch until reaching a threshold when it plateaued. By closely monitoring both the training and validation loss metrics, we verified that the model did not suffer from overfitting to the training data and exhibited strong generalization capabilities to unseen data.

In conclusion, these findings emphasize the efficacy of the LSTM Encoder-Decoder framework for text summarizing endeavors. Continuing with additional experimentation and adjusting hyperparameters could potentially improve the model's performance and result in more precise and useful summaries.

There are a number of areas that can be researched and developed in the future to make text summary even more accurate and useful. One possible direction is to combine more advanced neural network designs like Bidirectional LSTM (Bi-LSTM) and Graph Neural Networks (GNNs). By adding Bi-LSTM layers, the model can get environmental information from input patterns in both directions, which helps to understand the meaning and structure of the text more meaningfully.

Conflicts of interest/Competing interests

Author 1 receives salary from Bodoland University where he is working as an Assistant Professor and ensuing PhD degree in Assam University as a part-time research scholar.

Author 2 receives his salary from Mangaldai College where he is working as an Assistant Professor.

Author 3 receives salary from Assam University and working as a Professor.

Author Contribution

A.D. designed the problem and implemented by A.D. and A.B. both. S.R. prepares the manuscript flow and guided A.D. to write the manuscript. At last, all authors reviewed the manuscript for final submission.

Renjith S R, Sony P (20150 An Automatic Text Summarization For Malayalam Using Sentence Extraction. International Journal of Advanced Computational Engineering and Networking, Volume 3, Issue 8, pp. 46-50.
Vishal Gupta, GurpreetLehal (2012) Complete Pre Processing Phase of Punjabi Text Extractive Summarization System. Proceedings of COLING 2012: Demonstration Papers,COLING 2012, Mumbai, India, pp. 199–206.
Jagadish S Kallimani, Srinivasa K G, Eswara Reddy B (2010) Information Retrieval by Text Summarization for an Indian Regional Language. Proceedings of the 6th International Conference on Natural Language Processing and Knowledge Engineering(NLPKE-2010), pp. 1-4.
M. Hanuman Thappa, M. Narayana Swamy, N M Jyothi (2014) Automatic Keyword Extraction from Dravidian Language. International Journal of Innovative Science, Engineering and Technology, Vol 1, Issue 8, pp. 87-92.
ShubhamBhosale, Diksha Joshi, VrushaliBhise, Rushali A. Deshmukh (2018) Marathi e-Newspaper Text Summarization Using Automatic Keyword Extraction Technique. International Journal of Advance Engineering and Research Development, Volume 5, Issue 3, pp. 48-52.
Manjula Subramaniam, Vipul Dalal (2015) Test Model for Rich Semantic Graph Representation for Hindi Text using Abstractive Method. International Research Journal of Engineering and Technology (IRJET), Volume 2, issue 2, pp. 113-116.
M.Humera.Khanam, S.Sravani (2016) Text Summarization for Telugu Document. IOSR-Journal of Computer Engineering, Volume 18, Issue 6, pp. 25-28.
Md. Tawhidul Islam, Shaikh Mostafa Al Masum (2004) Bhasa: A Corpus Based Information Retrieval and Summarizer for Bengali Text. Proceedings of the 7th International Conference on Computer and Information Technology, Macquarie University, Sydney, Australia, pp. 1-5.
Kamal Sarkar (2012) Bengali text summarization by sentence extraction. Proceedings of International Conference on Business and Information Management (ICBIM-2012), NIT Durgapur, India, pp. 13-45.
Amitava Das, Sivaji Bandyopadhyay (2010) Topic Based Bengali Opinion Summarization. 3rd International Conference Computing Linguistics: Posters, Beijing, pp. 12 40.
Chandan Kalita, Navanath Saharia, Utpal Sharma (2010) An Extractive Approach of Text Summarization of Assamese using WordNet. Proceedings of the Association for Computational Linguistics (ACL), pp. 1-6.
Siddhi Barve, Shaba Desai, Razia Sardinha (2015) Query –Based Extractive Text Summarization for Sanskrit. Proceedings of the 4th International Conference on Frontiers in Intelligent Computing: Theory and Applications (FICTA), pp. E1-E3.
Jikitsha Sheth, Bankim Patel (2017) Saaraansh: Gujarati Text Summarization System. International Journal of Computer Science and Information Technology & Security (IJCSITS), Vol.7, No.3, pp. 46-53.

No competing interests reported.

Download PDF

Version 1

posted

You are reading this latest preprint version

Bodo Language Text Summarization Using Lstm Encoder-Decoder

Status:

Version 1

Abstract

Figures

1. Introduction

2. Literature review

3. Proposed Algorithm

4. Dataset Overview

5. WorkFlow of the proposed system

6. Architecture of the Proposed Algorithm(Lstm Encoder-Decoder)

Encoder:

Decoder:

7. Result Analysis

8. Conclusion

9. Future Scope

Declarations

Author Contribution

References

Additional Declarations

Status:

Version 1