Content uploaded by Sirojididn Komolov
Author content
All content in this area was uploaded by Sirojididn Komolov on May 27, 2021
Content may be subject to copyright.
TeleML : deploying trained Machine Learning
models in cross-platform applications
Sirojiddin Komolov, Youssef Youssry Ibrahim and Manuel Mazzara
Abstract Machine Learning (ML) is a fast-growing research and application field
which allows developers to utilize different implementation platforms. One of the
most common methods for implementing ML consists in deploying the trained
model in servers, and evaluate the user data through the communication between
a client app and a backend. This paper presents an alternative approach to the prob-
lem where the ML model is deployed in the client application, and discusses pros
and cons of this solution. As a case study a cross-platform application, TeleML, has
been developed. TeleML is a Telegram client allowing users to perform sentiment
analysis of posts that appear in chats. The experimental application does not feature
all the functionalities of the Telegram original client, but just those that are necessary
to perform sentiment analysis on a chat, for example sign-in, iterate over dialogs,
and choose a particular discussion. The findings show that, although the chosen
machine learning reaches the state-of-the-art performance and chosen frameworks
allow the developers utilize the model in the cross-platform environment using a
single programming language, the approach has limitations regarding user interface
and deployment onto the platforms where the performance play an important role,
such as mobile environment. The paper discusses technical aspects of the solution
as well as limitations and future work.
Sirojiddin Komolov
Innopolis University, Innopolis, Russia, e-mail: s.komolov@innopolis.ru
Youssef Youssry Ibrahim
Innopolis University, Innopolis, Russia, e-mail: y.ibrahim@innopolis.university
Manuel Mazzara
Innopolis University, Innopolis, Russia e-mail: m.mazzara@innopolis.ru
1
2 Sirojiddin Komolov, Youssef Youssry Ibrahim and Manuel Mazzara
1 Introduction
Machine learning (ML) has been for long discussed, researched and utilized mostly
in academia and major companies. However, recently, it has become more and more
popular and easy-to-use for real world applications, so that several companies are
now adopting ML techniques in their products and services [1]. Even though the ap-
proach of deployment of ML models in servers, and accessing them through various
services (i.e. micro-service), is becoming a common approach and has its own ad-
vantages (for example scalability and maintainaibility), there are obvious concerns
regarding this approach. Regarding deployment of ML models in the client-server
architecture we can identify the following issues:
• security concerns regarding user data sent to servers via various services
• servers can be overloaded by clients’ requests, as well as by evaluating user data
• performance decreases from user viewpoint due to the time spent on additional
requests to servers hosting ML models
This work analyses the method of deploying ML models into the client app, with
the objective of resolving the aforementioned concerns. The idea of developing all
the components of a system in one language is worth some attention too since such
approach may also simplify some aspects of the project: for example, the limitations
related to the requirement of developing skills in another programming language in
order to develop a ML model and a client side app. To evaluate the approach, the
authors have developed TeleML, an application consisting of a Telegram client. The
app utilizes a ML model that was trained earlier, and packaged along with the app.
The links to the source code of the ML model and TeleML app are presented in the
references. [25,26] The ML model carries out a process of automatically identifying
whether a given text is negative, neutral or positive, which is popular as a sentiment
analysis task. [17]
The following functionalities were implemeneted in the app: sign-in, sign-out,
iterate over dialogs and iterate over messages of a particular chat. The text messages
can be classified with the help of the ML model. Google BERT was chosen as the
ML algorithm. TeleML is written in Python in Kivy cross-platform development
framework. During the development several problems arose and this paper discusses
the affect of the problems onto the final solution.
The current paper discusses the job done in the following sections: Related work
section discusses the similar work on the chosen topics; Methodology section de-
scribes the ML model and the architecture of the app; Results section presents the
achievements of the ML model and the developed app; Discussions section contex-
tualizes the findings; Conclusions section summarizes the job done; and finally the
Future Work section discusses the future work based on the findings of the current
work.
TeleML : deploying trained Machine Learning models in cross-platform applications 3
2 Related work
At the best of our knowledge, most of the existing work focuses on the ML algo-
rithms and just a few papers discuss deployment techniques. For example, [19] is
one of the first works applying sentiment analysis on mobile devices, and utilizes
the SentiCorr technique for sentiment analysis; [21] focuses on Android devices and
discusses trade-offs between Android constraints (i.e. limited resources and CPU ar-
chitectures that allow only specific algorithms) and performance of algorithms. This
work however lacks the implementation of modern state-of-heart algorithms. The
research performed in [18] employs 17 sentiment analysis methods in an Android
device, but mainly focuses on the resource utilization and does not describe the
model deployment techniques [20] utilizes the Natural Language Toolkit (NLTK) to
perform sentiment analysis on the twitter tweets in a Rasperry device, but does not
explain much about employed sentiment analysis algorithms, aspects of deployment
etc.
The current paper tries to address the concerns regarding the deployment of a ML
model into a software application, specifically on a cross-platform environment, and
discusses the development of both the ML model and the software application.
3 Methodology
The following frameworks and libraries are used in the TeleML app:
• Python - as a programming language for the development of the ML model and
client interface
• BERT - as NLP algorithm for the sentiment analysis [2]
• Transformers library by HuggingFace - as a wrapper of the BERT algorithm. [3]
• Kivy cross platform framework - for user interface
•telethon for interacting with Telegram API in python
The next sub-sections discuss the ML model and the architecture of the app that
were built on the above frameworks and libraries.
3.1 ML model
The aim is to perform sentiment analysis on text, that is to classify sentences into
negative, neutral and positive. This is a traditional NLP task in the paradigm of
Deep Learning. As computers work well with numbers and do not have the abil-
ity to assimilate text, the first step would be to convert words into numbers, only
then, math operations could be done, and vectorize these numbers which is called
as tokenization in the NLP tasks [5]. In order to understand the meaning of a word,
4 Sirojiddin Komolov, Youssef Youssry Ibrahim and Manuel Mazzara
the context where it is used is very important and this should be taken into con-
sideration by the NLP technique [6]. Also, to achieve a reasonable accuracy there
should be large amounts of data from which a ML model could learn. The BERT [2]
algorithm, which stands for Bidirectional Encoder Representations from Transform-
ers shows superior results in addressing the above issues comparing to the classical
NLP algorithms [7]. Because, Google BERT comes with pre-trained models that
are trained on the large amount of text data, and one can achieve high performance
even with training on a relatively small number of training samples which is called
fine-tuning. [2] Transformers library from HuggingFace along with python torch li-
brary was used to implement Google BERT algorithm. [3] For tokenization process,
BertTokenizer with pre-trained ’bert-base-cased’ model was used. When encoding
the text using the tokenizer and in the training phase, the recommended parameters
presented in the Table 1 were applied.
Table 1: BERT parameters
max length 160
add special tokens True
return token type ids False
pad to max length True
return attention mask True
return tensors ’pt’
Batch size 16
Learning rate (Adam) 2e-5
But for the sake of higher performance the number of epochs was chosen: 10.
The Reddit dataset, which has about 37K rows and labelled as negative (-1), neutral
(0) and positive (1) [8], was used for fine-tuning. For validation and test, the dataset
was split into three: - 80% (29.7K rows) - for training data - 10% (3.7K rows) - for
validation data - 10% (3.7K rows) - for test data The model was fine-tuned, that is
trained on a Google Colab machine with 12 GB RAM and 15GB GPU NVIDIA-
SMI 455.45.01. After training the model, it was saved using the torch’s save model
to be used as pre-trained. It is worth to mention that, although the model was trained
with GPU, it was saved with CPU support so that the model could be utilized without
access to GPU.
3.2 Architecture of TeleML
The TeleML project follows the MVC principles for separation of concerns. [9] As
can be seen from the Figure 3, the TeleMLMain component acts as a controller,
while the components of the pages module act as a view. The model module has
TeleML : deploying trained Machine Learning models in cross-platform applications 5
two components classsifier and tele utils which are responsible for the ML model
utilization and working with telegram APIs respectively.
The KV language from the Kivy framework was used to declare the widgets in
*.kv files [10], so that the project is easy to maintain. Because the responsibility for
the user interface is shared between *.kv files (i.e. views.kv) and python files (i.e.
views.py) which utilizes the widgets declared in the *.kv files. Moreover, the View
components does not hold any logic, every action is sent to the controller, and the
controller decides what to do. By doing so, it is easier to control the workflow of
the project. The communication between views and the controller was implemented
through the events with the help of the pydispatcher library [11], because it is more
clean to apply the code presented in Figure 1 to notify a receiver about an action
rather than the code presented in the Figure 2 where the widget is trying to find the
controller widget from the root window in an error prone way.
As of writing this article, the 1.11.1 version of the Kivy framework has very prim-
itive looking core widgets, thus KivyMD library, which implements the Google’s
material design concepts [22], was employed for a better user interface, as material
design concepts are believed to improve user experience [23].
dispatcher.send(signal=self.signal_on_prev_click,
sender={})
Fig. 1: Code snippet of a sending an event
self.get_root_window().children[0]
.on_dialog_item_press(value_dialog_id,
value_dialog_title)
Fig. 2: Code snippet of a getting the controller widget from the root widget
The classifier component, which is responsible for utilizing the ML model, pro-
cesses the utilization in two phases:
1. Loading pre-trained models
2. Processing sentiment analysis on a given text
The controller initializes the first phase in the splash-screen, as it is a great time
to load resources during the period when a splash screen is shown. [12] In order to
support all the type of machines, the classifier is configured to be used with GPU
and without GPU.
The next component of the model module is tele utils which uses the telethon
library to utilize the telegram APIs. [13] The telethon library does all the heavy job,
such as encryption, caching an account etc, therefore security is provided by saving
6 Sirojiddin Komolov, Youssef Youssry Ibrahim and Manuel Mazzara
Fig. 3: The architecture of the TeleML application
the *.session file, which stores the sensitive account information, in user’s machine.
As mention earlier, the app implements the following telegram features:
• Sign-in
• Iterate over dialogs
• Choose a particular dialog and iterate over it’s messages
• Sign-Out
As large lists, such as dialogs or messages, can be retrieved from the Telegram’s
API in chunks, [14] the paging mechanism is implemented in the tele utils compo-
nent where each page is associated with a subset of items.
4 Results
As a result of implementation the mentioned architecture and frameworks described
in the Methodology section, the TeleML cross-platform app is ready. The following
subsections present the obtained results for the ML model, as well as the TeleML
app which utilizes the ML model and Telegram APIs into user interface.
4.1 ML model
The ML model achieved 94.83% performance. And it took 2 hours and 35 minutes
for training and validating the model on the Google Colab machine. The Figure 4
shows the performance tendency over the epochs while training.
TeleML : deploying trained Machine Learning models in cross-platform applications 7
Fig. 4: The training history of the ML model. The graph shows the training and the
validation accuracy of the model over the training epochs
The Table 3 shows the F1-score and performance on each of the predicted classes
(i.e. negative, neutral and positive). While loading the pre-trained model in the
splash screen took 4.2 seconds, predicting a text ”thank you a lot” took 0.3 sec-
onds. The time performance of the model was recorded in the machine, running the
TeleML app, with the characteristics presented in the Table 2.
Table 2: The performance of the machine running the TeleML
Model MacBook Pro (15-inch, 2018)
CPU 2,6 GHz 6-Core Intel Core i7
RAM 16 GB 2400 MHz DDR4
Battery charged status 20%
Free RAM status 3,14 GB
CPU load status 6%
4.2 TeleML application
As the TeleML app was developed on the cross-platform framework Kivy, the app
is ready to be packaged on the most popular platforms, such as Windows, Linux,
OSX, iOS and Android, but currently the app has been run and tested on the OSX
platform.
While showing the splash screen, which is represented in the Figure 5, the two
main processes are handled by the controller:
8 Sirojiddin Komolov, Youssef Youssry Ibrahim and Manuel Mazzara
Table 3: The classification report of the ML model
-precision recall f1-score support
negative 0.93 0.86 0.9 791
neutral 0.97 0.98 0.98 1333
positive 0.93 0.96 0.95 1591
-- - - -
accuracy 0.95 3715
macro avg 0.95 0.94 0.94 3715
weighted avg 0.95 0.95 0.95 3715
• The ML model is loaded onto the memory
• The Telegram account authentication is checked for authentication
The two above processes are done sequentially, that is once the ML model is
loaded, the controller requests tele utils module for authentication (telethon was
employed to check the authentication). If an user does not have a valid authentica-
tion, then the controller shows the sign-up screen, otherwise the dialogs screen is
displayed.
Fig. 5: The user interface of the Splash screen
The dialogs screen (see Figure 6) shows the list of dialogs, and allows an user
to iterate over dialogs via paging buttons. The list of dialogs are fetched through the
tele utils module. The screen also allows the user to logout of the telegram account
by pressing the sign-out icon located on the right-top of the screen. If the user clicks
on a dialog item, then the pressed dialog’s messages are shown in the the chat screen.
TeleML : deploying trained Machine Learning models in cross-platform applications 9
Fig. 6: The user interface of the Dialogs screen
The chat screen (Figure 7) also allows the user iterate over messages via paging
buttons. The messages are fetched through tele utils module. After the messages
are fetched, the text of the messages (if the text is not empty, of course) are classi-
fied into negative, neutral or positive along with confidence score through classifier
module. Then the parsed messages are displayed as list in the chat screen. A user
can press back button (which is located on the top-left corner of the screen) to get
back to the dialogs screen.
Fig. 7: The user interface of the Chat screen
10 Sirojiddin Komolov, Youssef Youssry Ibrahim and Manuel Mazzara
5 Discussions
So far the obtained the methods and achievements were presented in the earlier
sections and the following subsections will try to contextualize the ML model and
the TeleML app.
5.1 ML model
It can be seen from the Figure 4, that the model is performing well with no signif-
icant overfitting. The validation accuracy showed a fairly good performance which
gave us the confidence to utilize the model in the prediction of sentences in the
messages.
Talking about the accuracy of the ML model which is 94.83 %, the authors have
achieved the state-of-art performance. Since the performance of the BERT algorithm
is proven to be very high compared to other state-of-art algorithms, such as SVM
based TF-IDF, GLOVE and FastText, the score that current work achieved is fair.
Although the model is employed for telegram client, it can be applied in the
platforms for sentiment analysis which support python environment and meet the
specific performance requirements as the size of the model is comparatively large,
which is 700 MB, especially for platforms with relatively small performance (i.e.
mobile platforms). As of writing this article, the limit of an Android APK file to be
published on the Google play is 100 MB [15], so the current version of the app can
not be published onto the Google play without reducing the model size. Moreover,
the large size of the model causes long loading time, which is 4.2 seconds, in the
splash screen.
The next issue is that, the current version model only supports handling English
sentences, and if a message contains sentences in other languages, the prediction is
not correct and rather random.
5.2 TeleML
As the app is software product, we can discuss the app regarding suitable software
quality attributes. A security concern from the user viewpoint is addressed by the
app. That is the app stores the *.session file, which stands for a Telegram account
information, locally on the user’s machine, and interacts with Telegram API directly
with the help of telethon library, so that no-third-parties are involved. The next fact
is that the classification process is also handled locally as the app is shipped along
with the pre-trained model. Such approach is more secure than sending user data to
servers and validating the data in servers. However, shipping the pre-trained model
along with the app harms the intellectual property of the developers, because one
can easily extract the pre-trained model and use for his own needs.
TeleML : deploying trained Machine Learning models in cross-platform applications 11
As MVC pattern is implemented by the project, maintainability can be consid-
ered as addressed. Because, the logic of the app is divided into modules, which are
responsible for different areas of the app. This structure allows developers easily
edit functionality or add features into the app by only making changes into concrete
modules. Moreover, all the modules including the ML model are developed in one
programming language - Python gives developers another convenience of program-
ming.
Talking about the usability of the app, especially user interface, the fact that the
app follows material design concepts allowed to have modern good-looking user
interface. However, the Kivy framework lacks enough widgets and mechanisms to
achieve a desirable results. For example, the TeleML app has implemented pagi-
nation feature in the dialogs and chats screens on the bottom-right screen of the
layouts using buttons on page numbers, which requires a user to spend an extra
effort to navigate to the next/previous page. Instead, there are modern approaches
such as fetching and displaying the next page when a user reached the end of list
view by scrolling, often called as infinite scrolling. [16] But such approach is very
hard to achieve with the 1.11.1 version of Kivy framework. Also, building complex
dynamic layouts for an item in the list (i.e. Recycleview in the Kivy framework) with
the current version of Kivy is hard, so the user interface is too simple.
Authors have used Python programming language in all the modules of the app,
including the user interface, and the interaction with Telegram APIs, therefore for
developers of ML it would not require obtaining knowledge of other programming
languages for utilizing the developed ML models. So, the approaches taken by the
authors could be considered by developers of ML.
6 Conclusions
The TeleML includes several aspects of software development, including user inter-
face development, cross-platform development, working with Telegram APIs, and
deployment and utilization of the developed ML model. Such combination of soft-
ware frameworks and libraries gives us another angle to the ML development. As the
size of the ML model affected the app, i.e. the splash screen took long time to load,
the model size is too much for mobile platforms etc, the development phase of the
ML model should consider such concerns. Moreover, the ML developers should take
care about intellectual property of the ML model if the model is going to be shipped
along with an app. Also, when building user interface, the suitable UI framework
should be chosen according to the requirements. As the TeleML app shows, the Kivy
Framework is not ready yet for complex user interface.
Considering the above issues and approaches, the future work should consider
several aspects when deploying the ML model into software systems. First of all,
although the BERT algorithm shows significant results, other ML algorithms should
also be tested. The more robust and stable frameworks should be considered for the
user interface of an application, such as Flutter, React native etc. Moreover, the
12 Sirojiddin Komolov, Youssef Youssry Ibrahim and Manuel Mazzara
project should be judged by appropriate metrics which could evaluate the different
aspects, such as quality attributes etc. The ways of reducing the size of a pre-trained
models, which are to be shipped along with the application, should be considered.
References
1. M. Ribeiro, K. Grolinger and M. A. M. Capretz, ”MLaaS: Machine Learning as a Service,”
2015 IEEE 14th International Conference on Machine Learning and Applications (ICMLA),
Miami, FL, 2015, pp. 896-902, doi: 10.1109/ICMLA.2015.152.
2. Devlin, Jacob, Ming-Wei Chang, Kenton Lee, and Kristina Toutanova. ”Bert: Pre-training of
deep bidirectional transformers for language understanding.” arXiv preprint arXiv:1810.04805
(2018).
3. Wolf, T. and 21 colleagues, ”HuggingFace’s Transformers: State-of-the-art Natural Language
Processing,” 2019, arXiv, arXiv:1910.03771
4. Virbel, Mathieu, Thomas Hansen, and Oleksandr Lobunets. ”Kivy–a framework for rapid cre-
ation of innovative user interfaces.”Workshop-Proceedings der Tagung Mensch & Computer,
2011.
5. Prakash M Nadkarni, Lucila Ohno-Machado and Wendy W Chapman, ”Natural language pro-
cessing: an introduction,” Journal of the American Medical Informatics Association, Volume
18, Issue 5, September 2011, Pages 544–551, https://doi.org/10.1136/amiajnl-2011-000464
6. Cambria, Erik, Soujanya Poria, Alexander Gelbukh, and Mike Thelwall. ”Sentiment analysis
is a big suitcase.” IEEE Intelligent Systems 32, no. 6 (2017): 74-80.
7. Gonz´
alez-Carvajal, Santiago, and Eduardo C. Garrido-Merch´
an. ”Comparing BERT against
traditional machine learning text classification.” arXiv preprint arXiv:2005.13012 (2020).
8. Reddit database for sentiment analysis https://www.kaggle.com/cosmos98/
twitter-and- reddit-sentimental- analysis-dataset?select=
Reddit\_Data.csv, Last accessed: 6 Jan 2021
9. Goderis, Sofie. On the separation of user interface concerns: A Programmer’s Perspective on
the Modularisation of User Interface Code. Asp/Vubpress/Upa, 2008.
10. KV Language https://kivy.org/doc/stable/guide/lang.html, Last ac-
cessed: 6 Jan 2021
11. Driscoll, Mike. WxPython Recipes: A Problem-Solution Approach. Apress, 2017.
12. Tyers, Ben. ”Splash Screens and Menu.” In Practical GameMaker: Studio, pp. 129-138.
Apress, Berkeley, CA, 2016.
13. Exo, L. ”Telethon: Full-featured Telegram client library for Python 3 (1.11. 2)[Python].”
(2020).
14. Pagination in the Telegram API https://core.telegram.org/api/offsets, Last
accessed: 7 Jan 2021
15. Google play APK Expansion Files https://developer.android.com/google/
play/expansion-files, Last accessed: 7 Jan 2021
16. Babich, N. ”UX: infinite scrolling vs. pagination.” UX Planet 1 (2016).
17. Jain, Anuja P., and Padma Dandannavar. ”Application of machine learning techniques to senti-
ment analysis.” In 2016 2nd International Conference on Applied and Theoretical Computing
and Communication Technology (iCATccT), pp. 628-632. IEEE, 2016.
18. J. Messias et al., ”Towards sentiment analysis for mobile devices,” 2016 IEEE/ACM Interna-
tional Conference on Advances in Social Networks Analysis and Mining (ASONAM), San
Francisco, CA, 2016, pp. 1390-1391, doi: 10.1109/ASONAM.2016.7752426.
19. Chambers, Lorraine and Tromp, Erik and Pechenizkiy, Mykola and Gaber, Mohamed. (2012).
Mobile Sentiment Analysis. 10.3233/978-1-61499-105-2-470.
TeleML : deploying trained Machine Learning models in cross-platform applications 13
20. Mogoroase, Valentin. ”APPLICATIONS TO SENTIMENT ANALYSIS USING RASP-
BERRY AND DIFFERENT MICROCONTROLLERS FOR DATA STREAMS CLASSIFI-
CATION IN THE CONTEXT OF COVID-19.” Annals of the University of Craiova, Economic
Sciences Series 1, no. 48 (2020).
21. Tromp, Erik and Pechenizkiy, Mykola. (2011). SentiCorr: Multilingual Sentiment
Analysis of Personal Correspondence. Mathematical Programming. 1247-1250.
10.1109/ICDMW.2011.152.
22. KivyMD, ”Material Design for Kivy framework,” https://github.com/kivymd/KivyMD
23. Aiman M. Ayyal Awwad, Christian Schindler, Kirshan Kumar Luhana, Zulfiqar Ali, and
Bernadette Spieler. 2017. ”Improving pocket paint usability via material design compliance
and internationalization & localization support on application level”. In Proceedings of the
19th International Conference on Human-Computer Interaction with Mobile Devices and Ser-
vices (MobileHCI ’17). Association for Computing Machinery, New York, NY, USA, Article
99, 1–8. DOI:https://doi.org/10.1145/3098279.3122142
24. Piskorski, Jakub, Jacek Haneczok, and Guillaume Jacquet. ”New Benchmark Corpus and
Models for Fine-grained Event Classification: To BERT or not to BERT?.” In Proceedings
of the 28th International Conference on Computational Linguistics, pp. 6663-6678. 2020.
25. Source code of the ML model used in the TeleML app https://colab.research.
google.com/drive/1Ya4uJnmprza3NWIFo4lYMfAt2J5g2yOa?usp=sharing
26. Source code of the TeleML app https://github.com/Rhtyme/TeleML
