Ghost Code

App Architecture Study: Instagram

Gaurav — Fri, 24 May 2019 16:54:42 GMT

Instagram is one of the most used social media apps in Android and iOS. The core functionality of this app is around sharing photos instantly and it performs this function with a certain simplicity and elegance.

The simplicity of Instagram

We can learn a lot about design when we delve deeper into the design of Instagram. Over the years, Instagram has evolved in its design and with the addition of new features, edging closer to a more simpler design that highlights it’s core, the photos.

Check out the App breakdown in the following presentation:

Also check out this article: 10 Universal Design Principles as used by Instagram by Lauren Swainston, where some of the finer design principles used by Instagram are highlighted.

Disclaimer: The views and opinions expressed in this article are those of the authors and do not reflect the official analysis of Whatsapp. This article is a personal analysis based on a visual interpretation on the architecture of the app.

How to create the 'Share to' popup in Android using share intent?

Gaurav — Sat, 09 Mar 2019 14:33:49 GMT

Providing the option for users to share data from your app to another app is very useful. This feature maybe used just to share the install link of your app for reference credits or just for social sharing.

Google provides a very simple method of sharing data to other apps. This is using the Share Intent. Below shows the use of share intent, where a text and an image are shared:

File file = new File(getActivity().getCacheDir(), "app_promo.png");

Intent sendIntent = new Intent();
sendIntent.setAction(Intent.ACTION_SEND);
sendIntent.putExtra(Intent.EXTRA_TEXT, "Check out this awesome app");
sendIntent.putExtra(Intent.EXTRA_STREAM, Uri.fromFile(file));
sendIntent.setType("image/*");
context.startActivity(Intent.createChooser(sendIntent, "Share to:"));

If you use the above code in the OnClickListener of the Share button, you will have implemented the Share feature in your app. Yes, it is as simple as that

Custom Toolbar - Image on Toolbar in Android

Gaurav — Wed, 20 Feb 2019 09:28:05 GMT

The toolbar is one of the Material Design elements which is very versatile when used along with AppBarLayout. In this article, we are going to see how we can replace the standard toolbar of android with a custom toolbar that holds an image.

First, make sure to create a Basic Activity from the template picker and not the Empty activity as we need the Coordinator Layout with the App Bar Layout. Below you can see the default activity_main.xml generated:

 
<?xml version="1.0" encoding="utf-8"?>
<androidx.coordinatorlayout.widget.CoordinatorLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <com.google.android.material.appbar.AppBarLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:theme="@style/AppTheme.AppBarOverlay">

        <androidx.appcompat.widget.Toolbar
            android:id="@+id/toolbar"
            android:layout_width="match_parent"
            android:layout_height="?attr/actionBarSize"
            android:background="?attr/colorPrimary"
            app:popupTheme="@style/AppTheme.PopupOverlay" />

    </com.google.android.material.appbar.AppBarLayout>

    <include layout="@layout/content_main" />

    <com.google.android.material.floatingactionbutton.FloatingActionButton
        android:id="@+id/fab"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="bottom|end"
        android:layout_margin="@dimen/fab_margin"
        app:srcCompat="@drawable/ic_action_more" />

</androidx.coordinatorlayout.widget.CoordinatorLayout>

Create a new layout called toolbar.xml. We need to add the image in the Toolbar element. But as this element can have only one child, we will place our ImageView in a ConstraintLayout. Additionally, you can also set the background colour of the toolbar, below eg. shown uses the bg colour white.

Make sure to have the app_logo.png added to the drawable folder and support for respective screen sizes.

<?xml version="1.0" encoding="utf-8"?>
<android.support.v7.widget.Toolbar
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    android:layout_width="match_parent"
    android:layout_height="?actionBarSize"
    android:elevation="5dp"
    app:contentInsetLeft="0dp"
    app:contentInsetStart="0dp"
    android:background="@android:color/white">

    <android.support.constraint.ConstraintLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content">
        <ImageView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_marginEnd="8dp"
            android:layout_marginStart="8dp"
            android:src="@drawable/app_logo"
            app:layout_constraintBottom_toBottomOf="parent"
            app:layout_constraintEnd_toEndOf="parent"
            app:layout_constraintStart_toStartOf="parent"
            app:layout_constraintTop_toTopOf="parent" />
    </android.support.constraint.ConstraintLayout>
</android.support.v7.widget.Toolbar>

If you require a left or right icon for navigation, you can add them to the constraint layout with the respective constraints.

To add this custom layout to our main layout, we need to replace the standard Toolbar element with the custom layout like shown below:

<com.google.android.material.appbar.AppBarLayout
    android:layout_width="match_parent"
    android:layout_height="wrap_content">

    <include layout="@layout/toolbar" />
</com.google.android.material.appbar.AppBarLayout>

Here is the final activity_main.xml:

 
<?xml version="1.0" encoding="utf-8"?>
<androidx.coordinatorlayout.widget.CoordinatorLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity">

    <com.google.android.material.appbar.AppBarLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content">

        <include layout="@layout/toolbar" />

    </com.google.android.material.appbar.AppBarLayout>

    <include layout="@layout/content_main" />

    <com.google.android.material.floatingactionbutton.FloatingActionButton
        android:id="@+id/fab"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_gravity="bottom|end"
        android:layout_margin="@dimen/fab_margin"
        app:srcCompat="@drawable/ic_action_more" />

</androidx.coordinatorlayout.widget.CoordinatorLayout>

And voila! You now have a custom toolbar with an image icon.

Understanding and Leveraging Machine Learning in Conversational AI (using Rasa)

Gaurav — Mon, 31 Dec 2018 19:03:55 GMT

What makes a good conversation? A good conversation is one where you get the person you are speaking with interested in speaking, maybe by asking a few questions, making small talk and the filler conversation.

Consider this conversation:

Me: Hi, I am Gaurav.
John: Hi, I am John.
Me: How are you doing?
John: I am doing good. You?
Me: I am doing good too. So, I hear you are an expert on ML. So, can you tell me what it is?
John: Hmmm, ML stands for Machine Learning. It is the process of, er, a computer’s ability to learn by itself on providing some training data.
Me: Ah! I get it. Sort of like how a kid learns, right?
John: Yes, in it’s simplest form.
Me: And what is DL?
John: Well, DL stands for Deep Learning. It is more like a subset of Machine Learning. It mostly uses algorithms, somewhat based on the working of the brain. You would have heard of Artificial Neural Networks, right?
Me: Oh yes! So, Artificial Neural Networks like Convolutional Neural Networks and Recurrent Networks are part of DL?
John: Yes, indeed.
Me: Now I understand. Thanks for the explanation.
John: Anytime.

There is an interaction, a to and fro between me and John and through this conversation I get an idea of what Machine learning and Deep learning are. There are multiple ways this conversation could have played out and that dynamic interaction is what we are looking to replicate with ML.

Conversational AIs can conduct human-like interactions with humans using Natural Language Processing (NLP). They are evolved versions of the chatbots, that may serves up automated responses or a default fallback response. Conversational AIs are essentially smart chatbots.

Consider a simple bot that tells you more about Coffee, the startup that I spend most of days at.

On being asked “How are you?”, the bot responds “Wonderful! Thanks for asking.” It even thanks you for asking. There is a lot of to and fro in this conversation and you can go through it in the image. I would like to bring your attention to the last message, “I know, right?” in response to my “Oh! Great.” That sort of dynamic interaction or I would say, more of a reaction to my statement is what makes a bot smart and this is where ML and AI play a major part.

So, lets have a look at what are the options for building such a bot.

The Chatbot Ecosystem

There are multiple ways of going about building a smart conversational AI. You can leverage bot building platforms such as DialogFlow, IBM Watson, wit.ai, recast.ai, Rasa and more. Bot building platforms allow you to build an end to end conversational NLP with the ability to process and predict an action based on your intent. These platforms also provide options for integrating with a frontend platform of your choice.

Chatbot Ecosystem. Source: Recast.ai

Optionally, you can opt in for NLP providers such as Rasa NLU, wit.ai, IBM Watson, AWS and more. These platforms provide you only the Natural Language Processing part upon which you can build your custom processing and ML model to generate a conversational flow.

Flow of Conversational AI

A basic Conversational AI takes in the user request via text or voice, and passes it to the following modules:

Connector modules:
This is the conversational platform, the frontend, and can be a website or app, where the user interacts with the AI.
Input Modules:
The user request is feed to this module, which does Natural Language Understanding.
Dialogue Management
This module takes the NLU text and maintains the context of the conversation. It then uses Machine Learning model such as an RNN or LSTM to suggest an appropriate action to be taken. This module can also be connected to a backend or database to perform additional processing based on suggested action.
In the below example, it recognizes that the user is requesting the weather and connects to the weather API to perform the appropriate action.

Source: Rasa

Output Modules
This module performs Natural Language Generation to return an appropriate response to the user.

The user is sent back a AI response via text or voice through the Connector Module.

Conversational AI with Rasa

Rasa is an open source bot framework, which can be used to build contextual AI assistants and chatbots. It has the following 2 components:
1. Rasa NLU, which interprets the user message.
2. Rasa Core, which tracks the conversation and decides what happens next. Rasa Core suggests the most appropriate action to be taken

Rasa Stack. Source: Rasa

Rasa doesn’t have any pre-built models on a server that you can call using an API. You will need to prepare the training data and load it into Rasa. However, you are in complete control of all the components of your chatbot, which makes it totally worth the time.

Let’s take a closer look at the 2 components of Rasa stack and how they work with NLP and ML.

Natural Language Understanding (Rasa NLU):

Rasa NLU processes user input text and understands what the user is trying to say. Basically, it takes the user text as input and extracts the intent and entities from it.

Intent: An intent represents the purpose of a user’s input, what the user wants to do. The user input text is first vectorized and then the intent of the text is extracted.
Entity: An entity represents a term or object that is relevant to your intents and that provides a specific context for an intent.

Taking the example of the “What’s the weather like tomorrow?”, we can get the following:

Intent: “request_weather” =>User is requesting for the weather.
Entity: { “date”: “tomorrow” } => When is the user requesting the weather for?
You can define additional intents based on your application. For eg., you can also define a “place” entity, so that you can understand which place the weather should be requested from.

Rasa NLU. Source: Rasa

For a breakdown and the deeper understanding of the Rasa NLU, you can check out an article I previously wrote on Understanding Rasa NLU.

Dialog Handling (Rasa Core):

Upon extracting the data from user input, the intent and entities are passed to Rasa Core. RasaCore decides what happens next in this conversation. It uses machine learning-based dialogue management to predict the next best action based on the input from NLU, the conversation history and your training data.

Dialog Handling. Source: Rasa

Rasa Core uses a neural network implemented in Keras, with the default model architecture based on LSTM to predict the next action.

LSTMs (Long Short Term Memory networks) are a special kind of Recurrent Neural Network (RNN), capable of selectively remembering patterns for long durations of time. LSTMs can thus help in maintaining the context of conversations and also predicting the next action. You can check out this article on the Introduction to LSTM to understand LSTMs further. You can also check out this presentation by Vishal Gupta.

For our example of the weather request, an action of “location_question” or “weather_api_call” is suggested. Finally, based on the action type, the relevant response is generated by the Rasa NLG, which is part of Rasa Core.

This covers the basics of how machine learning is used to build a Conversational AI. Now you will have an understanding of the flow of conversation and how the different components of Rasa come together to perform the required tasks. A major advantage of Rasa is that the components are interchangeable. You can make use of Rasa Core and Rasa NLU separately plugging it into your custom built models.

You can get started with building your first Rasa Conversational AI by checking out this Google colab notebook: https://colab.research.google.com/drive/1pIcv7eEKhNnl2zf4JPl9FvTv1sInlhBT

If you have any comments, I’d be happy to discuss further. Respond here or find me on twitter

General Resources: Interesting Frameworks, Articles & Videos

Gaurav — Sat, 01 Sep 2018 22:36:19 GMT

Below you will some interesting resources and articles that will help you in your development journey. Have a look and you may find something that will help in the learning process.

CodingRadio provides you with music to help you focus
https://codingradio.xyz/?ref=producthunt

Compendium Maps: a visual summary of the climate debate
http://bit.ly/2Kh6qq0

Welcome to Debatepedia! – Debatepedia, the Wikipedia of Debates
http://bit.ly/2tupMUY

HTML5 Game Framework
http://phaser.io

Stealthy – Secure decentralized communication
https://www.stealthy.im

Trusting Trust – an experiment
https://agnelvishal.github.io/TrustingTrust/pc/index.html

Articles and Reading Resources:

Want to know how to hack websites??
https://cnhv.co/3durm

Amazing thread on Probablistic Programming in a real life scenario.
https://news.ycombinator.com/item?id=17220861

E823: Lambda School CEO Austen Allred created an immersive online training for software engineers at no upfront cost, disrupts education by eliminating student debt & aligning incentives of his school with those of its learners
http://thisweekinstartups.com/austen-allred-lambda-school/

Resume Skills list
http://www.thisisinsider.com/best-resume-skills-list-linkedin-jobs-2018-4

Richard Stallman extreme views on computing.
https://stallman.org/stallman-computing.html

Top 8 Programmer Hobbies
http://bit.ly/2I83ONW

“5 Steps to Online Privacy with Firefox”
https://medium.com/@jovanovski/5-steps-to-online-privacy-with-firefox-b33a2e72416c

Microsoft’s free courses
https://www.linkedin.com/feed/update/urn:li:activity:6387123787783114754/

Sierra Leone just ran the first blockchain-based election
https://techcrunch.com/2018/03/14/sierra-leone-just-ran-the-first-blockchain-based-election/

Wall Street rethinks blockchain projects as euphoria meets reality
https://www.reuters.com/article/us-banks-fintech-blockchain/wall-street-rethinks-blockchain-projects-as-euphoria-meets-reality-idUSKBN1H32GO

The Importance of Using Strong Keys in Signing JWTs
https://auth0.com/blog/brute-forcing-hs256-is-possible-the-importance-of-using-strong-keys-to-sign-jwts/

Where to store your JWTs
https://auth0.com/docs/security/store-tokens#where-to-store-your-jwts

How to design for everyone?
www.fastcompany.com/90160000/how-to-design-for-everyone-in-3-steps

Raspberry Pi:

Raspberry Pi Internet Radio
http://www.bobrathbone.com/raspberrypi/pi_internet_radio.html

Raspberry Pi FM Transmitter
https://www.raspberrypi.org/magpi/raspberry-pi-fm-transmitter/

REST API Clients:

Postman
https://www.getpostman.com/

Postman is an API development environment,

Swagger
https://swagger.io/

Swagger aides in development across the entire API lifecycle, from design and documentation, to test and deployment

Insomnia REST Client
https://insomnia.rest/

Reuse API keys or session IDs.

Videos:

The four pillars of a decentralized society
https://youtu.be/8oeiOeDq_Nc

Project SHIVOM (Official Video) | Powering the Next Era of Genomics through Blockchain
https://youtu.be/jce9vB5zbps

Secrets of the DOM Virtual Machine
https://youtu.be/kD3LaHtwMm8

Build real-world games with Google Maps APIs
https://youtu.be/QC51FEF0JeY

The Art of Writing Software
https://www.youtube.com/watch?v=QdVFvsCWXrA&feature=youtu.be

NodeJS in Tamil
https://www.youtube.com/watch?v=J8GyTIHc-T4

* * *

If you have any comments, I’d be happy to discuss further. Respond here or find me on twitter

Originally published in build2learn.in

GitHub Repos that you should check out

Gaurav — Mon, 20 Aug 2018 14:32:23 GMT

Github is a very useful source of a lot of open source projects. If you find any repo of your interest from the list below, fork it and go through the code. Reverse engineering is a good way to learn. This process will give you a lot of questions, which in the process of understanding and answering will help you expand your knowledge.

Mother of all demo apps
https://github.com/gothinkster/realworld

Build your own (insert technology here)
https://github.com/danistefanovic/build-your-own-x

List of Free Software network services and web applications which can be hosted locally.
https://github.com/Kickball/awesome-selfhosted

Face detection library in 200 lines of JS
https://github.com/tehnokv/picojs/

Watch matches in a terminal
https://github.com/cedricblondeau/world-cup-2018-cli-dashboard?ref=producthunt

“Backblaze B2 provides the cheapest cloud object storage and transfer available on the internet. Comparatively, AWS S3 is 320% more expensive to store and 400% more expensive to transfer to the internet.”
https://github.com/sibblegp/b2blaze

A tool to encrypt files on git, and you can maintain an oss project without giving up your keys.
https://github.com/AGWA/git-crypt

Rasa NLU – Turn Natural Language into structured data:
https://github.com/RasaHQ/rasa_nlu

Useful resource for Tamil machine learning applications.
https://github.com/Ezhil-Language-Foundation/open-tamil

Tamil text to speech
https://github.com/tshrinivasan/tamil-tts-install

YouTube downloader
https://rg3.github.io/youtube-dl/

A personal terminal-based dashboard utility, designed for displaying infrequently-needed, but very important, daily data
https://github.com/senorprogrammer/wtf

An interesting decentralized alternative to Slack.
https://github.com/ssbc/patchwork

YouTube Downloader
https://rg3.github.io/youtube-dl/

Whatsapp Web bot:
https://github.com/bruno222/whatsapp-web-bot

The only cheat sheet you need
https://github.com/chubin/cheat.sh

A list of SWAG opportunities
https://github.com/swapagarwal/swag-for-dev

* * *

If you have any comments, I’d be happy to discuss further. Respond here or find me on twitter

Originally published in build2learn.in

Resources for Machine Learning: From the basics to working models

Gaurav — Sun, 12 Aug 2018 10:47:52 GMT

The textbook definition of Machine Learning goes something like this: a subset of Artificial Intelligence that uses statistical techniques to get computers to learn without being explicitly programmed. Simply put, Machine Learning is making computers learn like humans by training it.

Below you will find a pool of resources from cheatsheets to working models that will get you started in the field of ML.

Machine Learning Cheatsheets
https://www.rankred.com/machine-learning-cheat-sheets/

Top-down learning path: Machine Learning for Software Engineers
https://github.com/ZuzooVn/machine-learning-for-software-engineers

Tutorial for Andrej Karpathy’s CNN Course! Really comprehensive tutorial to start from scratch
http://cs231n.github.io/

Making neural nets uncool again
http://www.fast.ai

NLP using Torch
https://harvard-ml-courses.github.io/cs287-web/

Lip Reading – Cross Audio-Visual Recognition using 3D Convolutional Neural Networks
https://github.com/astorfi/lip-reading-deeplearning

Collection of Interactive Machine Learning Examples
http://tools.google.com/seedbank/

Glow: Better Reversible Generative Models
https://blog.openai.com/glow/

Neural Network based Startup Name Generator
https://www.kdnuggets.com/2018/04/neural-network-startup-name-generator.html

Neural Joke Generation
https://web.stanford.edu/class/cs224n/reports/2760332.pdf

Keras Models in the browser
https://transcranial.github.io/keras-js/#/

Font Meme Generator
https://fontmeme.com/text-generator/

Tensorflow.js
https://js.tensorflow.org

Build a DNA-personalized app
https://genomelink.io/developers/

Tensorflow Dev Summit 2018 keynote
https://www.youtube.com/watch?v=kSa3UObNS6o&feature=youtu.be

TensorFlowJS: Machine Learning In JavaScript
https://youtu.be/656l4IfhM10

Articles and Reading Resources:

Self-Study Machine Learning Projects
http://bit.ly/2IFA1YT

Project- Gun Detector (a custom object detector)
Teammate- Jyot Prakash Verma
Framework Used – Tensorflow
https://www.linkedin.com/feed/update/urn:li:activity:6409461318050508800

How a Beginner Used Small Projects To Get Started in Machine Learning and Compete on Kaggle
http://bit.ly/2IFnqFr

Why ML interfaces will be more like pets than machines « Pete Warden’s blog
bit.ly/2MgTX7A

Building Mobile Applications with TensorFlow – a free book
https://oreil.ly/2JGh7Cv

Fruit Decay detection
http://www.ijircce.com/upload/2016/august/150_fruittedection.pdf

Facial emotion recognition
https://medium.com/@rishiswethan.c.r/emotion-detection-using-facial-landmarks-and-deep-learning-b7f54fe551bf

WaveNet is being used to generate the Google Assistant voices for US English and Japanese across all platforms
https://deepmind.com/blog/wavenet-launches-google-assistant/

How to learn deep learning in 6 months
https://towardsdatascience.com/how-to-learn-deep-learning-in-6-months-e45e40ef7d48

Reading an Academic Paper — DL/ML/AI
https://blog.goodaudience.com/reading-an-academic-paper-dl-ml-ai-2fa02976a571

AI:

AI Principles by Google
https://www.blog.google/topics/ai/ai-principles/

AI Researchers from Google, Microsoft & Facebook answer questions
https://www.reddit.com/r/science/comments/7yegux/aaas_ama_hi_were_researchers_from_google/?utm_source=reddit-android

Browse passages from books using experimental AI
https://books.google.com/talktobooks/

Datasets:

Yelp dataset
https://www.yelp.com/dataset/download

Let’s Go dataset
https://github.com/DialRC/LetsGoDataset

Chatbots:

CakeChat: Emotional Generative Dialog System – as used in Replika
https://github.com/lukalabs/cakechat

Rasa NLU
https://github.com/RasaHQ/rasa_nlu

Making a simple Telegram Bot
http://www.developintelligence.com/blog/2017/08/building-serverless-chatbot-aws-zappa-telegram-api-ai/

Messages with a fake virtual companion
https://www.kaggle.com/eibriel/rdany-conversations

Bot Testing

http://dimon.co/

http://bottesting.co/

https://www.quora.com/How-do-you-test-chatbot

* * *

If you have any comments, I’d be happy to discuss further. Respond here or find me on twitter

Originally published in build2learn.in

Python Resources: Getting Started to Going Full Stack

Gaurav — Sat, 28 Jul 2018 15:29:04 GMT

Python is one of the most used languages. Whether you are starting out with the basics of programming or if you want to build a full stack web app or a smart machine learning algorithm, python is a great language that will you seamlessly implement your solution. Check out some really useful resources below that will get you started on your journey or assist you on your path.

Learn python in Y Minutes
http://bit.ly/2KPiAqP

Flask – Full Stack Python
http://bit.ly/2IZS0tg

Django — Getting Started with the Python Web Framework
https://docs.djangoproject.com/en/2.1/intro/overview/

Beautiful Soup — Web scraping in python
https://www.crummy.com/software/BeautifulSoup/bs4/doc/

An easier way to use pygame
http://bit.ly/2NyIcdu

A simple Pythong GUI Library.
http://easygui.sourceforge.net/

Developing a Single Page App with Flask and Vue.js
https://testdriven.io/developing-a-single-page-app-with-flask-and-vuejs

Python projects – Modules – Code Club
http://bit.ly/2u4jlFs

What are small projects to build for a beginner in Python? – Quora
http://bit.ly/2u0HxbG

awesome-python – A curated list of awesome Python frameworks
https://github.com/vinta/awesome-python

Data streaming in Python: generators, iterators, iterables | RaRe Technologies
https://rare-technologies.com/data-streaming-in-python-generators-iterators-iterables/

Python 3.7 new features
https://realpython.com/python37-new-features/

Use coupon FBFREE18 and get 100% discount on Python course at udemy. Here is the link for the same
https://www.udemy.com/python-complete/\

This is a Python/Django based event management system. A meetup clone.
http://bit.ly/2rKJJ5V

Invent with Python
https://inventwithpython.com

Game obstacles
https://github.com/nerd455/ObstacleGame

Scientific Python in the Browser
http://droettboom.com/blog/2018/04/04/python-in-the-browser/

Open Source Python Game Agent Framework
http://serpent.ai

PySpark- Transformation & Actions
https://drive.google.com/file/d/1c5Koaz6krkUIunsieL1V-AYBbQKiXab4/view

* * *

If you have any comments, I’d be happy to discuss further. Respond here or find me on twitter

Originally published in build2learn.in

Getting Started with Machine Learning: Starting at the End by understanding Rasa NLU

Gaurav — Tue, 10 Jul 2018 10:00:21 GMT

Getting started with Machine Learning is a daunting task. Where do I start in this complex maze? Should I start in the center or at the edges? Math or Algorithms?

What made sense was to start at the end. But what end? There are many projects that have been built with ML. So, which one do I choose? The choice was made easier for me when Bhavani Ravi was working to understand a project that has already built using Machine Learning for Natural Language Processing (NLP) — Rasa NLU. My interest in NLP was at an all time high because of my recent project in chatbots. This was serendipity, two mangoes with one stone.

What does Rasa NLU do? Rasa NLU is a tool for understanding what is being said in short pieces of text. For example, by taking a short text message like:

“I’m looking for a Chinese restaurant in my area”

It returns structured data like:

intent: search_restaurant
  entities: 
    - cuisine : Chinese
    - location : my area

Beginning at the Start

First, we looked at the command that should be executed to start training of our model:

python -m rasa_nlu.train \
    --config sample_configs/config_spacy.yml \
    --data data/examples/rasa/demo-rasa.json \
    --path projects

This led us to the train.py in the rasa_nlu folder. Thats where all the magic happens (or atleast the training in this case). Digging deeper, we found the do_train() function, which is called on executing the above command. It takes the config, data and path specified during execution.

This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters

Show hidden characters

	def do_train(cfg, # type: RasaNLUModelConfig
	data, # type: Text
	path=None, # type: Optional[Text]
	project=None, # type: Optional[Text]
	fixed_model_name=None, # type: Optional[Text]
	storage=None, # type: Optional[Text]
	component_builder=None, # type: Optional[ComponentBuilder]
	url=None, # type: Optional[Text]
	**kwargs # type: Any
	):
	"""Loads the trainer and the data and runs the training of the model."""

	trainer = Trainer(cfg, component_builder)
	persistor = create_persistor(storage)
	if url is not None:
	training_data = load_data_from_url(url, cfg.language)
	else:
	training_data = load_data(data, cfg.language)
	interpreter = trainer.train(training_data, **kwargs)

	if path:
	persisted_path = trainer.persist(path,
	persistor,
	project,
	fixed_model_name)
	else:
	persisted_path = None

	return trainer, interpreter, persisted_path

view raw

train.py

hosted with ❤ by GitHub

Trainer

Now, in the do_train() function, we see that the Trainer model is initially called.

trainer = Trainer(cfg, component_builder)

Two arguments are passed to the Trainer model in model.py:

config (sample_configs/config_spacy.yml) to use for the training, and
component_builder, which is the pipeline specification. In our case, we had not specified the component_builder.

The Trainer basically loads the config and uses the component_builder to build a trainer model. As we had not specified the component_builder, the default spaCy component pipeline is loaded for us because of the specified spaCy config.

SpaCy Language Processing Pipeline

Persistor

The next function is the persistor, which functions to store the data. You can specify AWS, GC, Azure or None. This is optional and we did not specify the same.

persistor = create_persistor(storage)

Training Data

Next, the training data can be taken from either the url or from local. We had specified the data in local with our command (data/examples/rasa/demo-rasa.json).

if url is not None:
      training_data = load_data_from_url(url, cfg.language)    
else:
      training_data = load_data(data, cfg.language)

Interpreter

This data is sent to the trainer, we had created above for training and generating an interpreter.

interpreter = trainer.train(training_data, **kwargs)

The train() function in the Trainer model gets the training_data and iterates through it to generate a spaCy model. This is returned as the interpertor, which can interpret the input data and give structured data output.

Persisted Path

If path is provided, as in our case (projects) data is persisted to the path.

The Result

And finally, the do_train() function returns the trainer, the interpreter and the persisted_path. Now, we can make use of the generated interpreter for getting intents and the entities. This can further be used for Natural Language Understanding, which is what is used in the Rasa core.

Lightsaber locked and loaded

Equipped with this knowledge of how a trainer works in a final NLP product, I began my journey deeper into Machine Learning. I do have more questions than when I started, but at least now I know where to look and what direction to take. So, sometimes, it is better to start at the end and then go back to the beginning. This way you will get a load of questions, which will help you direct your focus towards a path that will take you in deeper.

Hope this article helped you also get started or enhanced your experience with Machine Learning. Do feel free to drop any queries that you have below.

* * *

Originally published on July 7th, 2018 at medium.com

How to remove padding around button widgets in Android?

Gaurav — Tue, 16 May 2017 18:25:28 GMT

When using the default button widget in Android, you can see that the button comes with its own preset padding. When trying to stylize the button with a custom background, it gets really annoying to have this fixed background.

You can remove the padding around the button by using setting the minWidth and minHeight to 0.

How to display HTML content in UILabel Swift 3

Gaurav — Fri, 21 Apr 2017 18:11:34 GMT

First we take a HTML string as input and then process this string to generate an Attributed String which can be set to the UILabel. Below are the steps in the process:

Data is taken from the string using the unicode encoding.

let data = string.data(using: String.Encoding.unicode, allowLossyConversion: true)

Using the NSHTMLTextDocumentType, an NSAttributedString is generated.

if let d = data {
    let str = try NSAttributedString(data: d,
        options: [NSDocumentTypeDocumentAttribute: NSHTMLTextDocumentType],
        documentAttributes: nil)
    return str
}

This string can be set to the UILabel to display HTML formatted text.

myLabel.attributedText = str

Have a look at the complete function below:

private func stringFromHtml(string: String) -> NSAttributedString? {
    do {
        let data = string.data(using: String.Encoding.unicode, allowLossyConversion: true)
        if let d = data {
            let str = try NSAttributedString(data: d,
               options: [NSDocumentTypeDocumentAttribute: NSHTMLTextDocumentType],
               documentAttributes: nil)
            return str
        }
    } catch {
        print ("Failed to get HTML from string")
    }
    return nil
}

This function has been written in Swift 3.

How to get the time in Android relative to current time? - In number of seconds, minutes, hours or days ago

Gaurav — Wed, 08 Mar 2017 23:23:20 GMT

Many a time, we shall be dealing with time in a number of varied DateTime formats. We have discussed about some of the ways to standardize DateTime in a previous article. In this article, we shall learn how to get the time relative to current time.

Without further adieu, lets jump into the code. We shall be working with the input time in milliseconds (Refer this article on how to parse the date and get time in milliseconds). we then get the current time in milliseconds using System.currentTimeMillis().

long now = System.currentTimeMillis();

Then we check if currentTime is greater than inputTime, meaning the inutTime is in the past, and then find the difference between the inputTime and currentTime. We convert the difference to seconds, minutes, hours, days, months and years to determine its relativity. Check out the entire code below:

// inputTime in milliseconds
public static String getRelativeTime(long inputTime) {
    long difference = 0;
    // Get the current time in milli seconds
    long currentTime = System.currentTimeMillis();

    if (currentTime > inputTime) {
        difference = currentTime - inputTime;
        final long seconds = difference / 1000;
        final long minutes = seconds / 60;
        final long hours = minutes / 60;
        final long days = hours / 24;
        final long months = days / 31;
        final long years = days / 365;

        if (seconds < 60) {
            return seconds == 1 ? "one second ago" : seconds + " seconds ago";
        } else if (seconds < 120) {
            return "a minute ago";
        } else if (seconds < 2700) { // 45 * 60
            return minutes + " minutes ago";
        } else if (seconds < 5400) { // 90 * 60
            return "an hour ago";
        } else if (seconds < 86400) { // 24 * 60 * 60
            return hours + " hours ago";
        } else if (seconds < 172800) { // 48 * 60 * 60
            return "Yesterday";
        } else if (seconds < 2592000) { // 30 * 24 * 60 * 60
            return days + " days ago";
        } else if (seconds < 31104000) { // 12 * 30 * 24 * 60 * 60
            return months <= 1 ? "One month ago" : days + " months ago";
        } else {
            return years <= 1 ? "One year ago" : years + " years ago";
        }
    }
    return null;
}

Links that you must follow while developing for Android

Gaurav — Thu, 12 Jan 2017 12:46:12 GMT

While developing for android, getting an idea of the design to choose or what functionality to implement is a hassle. So below are a set of links that you can use to make your life easier when developing for android:

Android Official Developers site: The official Android developers site is one of the best resources for Android development. With updates about the latest version of the android OS as well as tutorials for the newest features, this site is a very useful resource. You can also find the documentation of all the Java classes that are available with each Android version, grouped via API. The best thing about this site is it comes bundled with your SDK installation, so that you can also use it offline.
Stack Overflow: If you have developed before, you would have surely come across stack overflow. You can find answers to a wide range of issues that you come across while developing here and also post questions in case you can’t find a solution.
Material Design: The official Material design site contains all the specs of the new Material design that was introduced with Android 5.0, which are constantly updated. The material design site also contains guidelines, which in their words: “This spec is a living document that will be updated as we continue to develop the tenets and specifics of material design.”
The Android Developer’s Blog: Whether it is a new official update or a new feature tutorial, the Android developer blog is the best place to get the information. With inside info and latest news updates regarding Android, this blog is must to be followed.
Github: Github contains a wide range of repositories of projects, tools and libraries that you can use in your app. Github is also a very useful version control tool for your app. Check out this article for a way to setup Android Studio with Github.
Android arsenal: Android arsenal, just like Github contains a categorized directory of libraries, tools and apps that you can use for in your app or as a reference for development.
Google: Last but the best of them all, Google is one of the best places to find solutions to your problems. All you have to do is ask the right question.What do you think of this list? Do you have any other link that you think can be added? Comment it below.

How to enable Version Control in Android Studio using Git & Github?

Gaurav — Wed, 14 Dec 2016 16:22:34 GMT

Github is one of the most widely used web-based version control systems, based on Git. It is a useful source code management tool, where you can keep track of versions of your app and all the changes between it.

Version control helps you keep a track of changes and rollback to a previous version if there are any errors in the current version. Github makes this easier by providing a means to compare the code between commits and also preview parts of the code online. Code uploaded to github are stored in public repositories (accessible to everyone). Private repositories are available at $7/month.

Android Studio comes inbuilt with a number of choices for Version Control Systems, with options to use Git as well as Github. To make use of Github, signup for an account at github.com. If you are a student, make sure to sign up for the Student developer pack, where you are eligible to use private repos.

Below are the steps on how to setup the version control using Git & github for your project:

Once you have signed into your Github account, click on the plus icon next to your profile icon and choose new repository.
In the following page, enter a repository name and description. You can choose the repo to be private or public. Be careful not to select the Initialize this repository with a README (otherwise you will not be able to push your code into the repo. You will then have to pull the code first and then push it).
Once the repo has been created, you will then get a link to access it. Make a note of that link. So in this case, the link to the repo I created is: https://github.com/TheCoffee/alertdialogs.git
Now head over to Android Studio. In your project, select VCS -> Import into Version Control -> Create Git Repository.
In the window that popups, select the project directory for git init. This is the directory that will be synced with the git repo. So in my case, I have chosen my project AlertDialogs. Once you click on this, all the files in the Project pane will become red.
Add your project directory to your local git repo. You can do this by right clicking on your project folder and selecting Git -> Add. Once you click on this, all the files in the Project pane will become green.
Right click on your project and select Git -> Commit Directory… On committing, the files in the Project pane will return to their original color (black).
Add a commit message. Click on Commit and select Commit…
Confirm the commit. You can also review the warnings and errors if any and correct them before committing the git repo.
On committing your project, right click on it. Select Git ->Repository->Push… This is to push the local git repository to Github.
In the new popup, select Define remote. A window will popup asking for the Name and URL to the github repository. Paste the url of the git repository that you had copied in Step 3: https://github.com/TheCoffee/alertdialogs.git
On clicking OK, the git repo will be verified and you will now be connected to the master branch. You can choose to push your repo to any other branch of your repo by selecting master and changing it here.
Push the repository to Github. You will get the following message on successful push. If the push fails, check that the github repo is empty. If not (if there is a README.md file), then right clicking on your project directory, choose Git->Repository->Pull. Then, repeat the process from Step 10.
Now you can view your repository in your Github account. you will also be able to see the Commit message that you specified.

So now, you have a version control system in place for your project. With this system, keep track of the changes in your project. This system makes it easy to collaborate with others so that review your code and assist in the development process.

App Rating popup: Creating a Rate My App Alert Dialog

Gaurav — Sat, 03 Dec 2016 21:32:42 GMT

We have already seen the Alert Dialog used to give the users a warning in a simple dialog and for the About and Feedback Dialog. This article illustrates the use of the AlertDialog for requesting the user to rate your app.

The RateAppUtil keeps track of the number of times the app has been opened and the number of days since the app has been opened and then accordingly shows the Rate App AlertDialog.

Have a look at the code that has been use to achieve this.

Final Code:

import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.SharedPreferences;
import android.net.Uri;
import android.support.v7.app.AlertDialog;

public class RateAppUtil {
    private final static String APP_TITLE = "MechByte";

    // Package name of the app as uploaded in the play store
    private final static String APP_NAME = "com.coffee.mechanicalbyte";

    // No of days until the app rater is shown
    private final static int DAYS_UNTIL_PROMPT = 2;
    // No of app launches until the app rater is shown
    private final static int LAUNCHES_UNTIL_PROMPT = 4;

    private Context mContext;

    public RateAppUtil(Context context) {
        mContext = context;
    }

    public void appLaunched() {
        SharedPreferences prefs = mContext.getSharedPreferences("appRater", 0);
        if (prefs.getBoolean("dontShowAgain", false)) {
            return;
        }

        SharedPreferences.Editor editor = prefs.edit();

        // Increment launch counter
        long launchCount = prefs.getLong("launchCount", 0) + 1;
        editor.putLong("launchCount", launchCount);

        // Get date of first launch
        Long dateFirstlaunch = prefs.getLong("dateFirstLaunch", 0);
        if (dateFirstlaunch == 0) {
            dateFirstlaunch = System.currentTimeMillis();
            editor.putLong("dateFirstLaunch", dateFirstlaunch);
        }

        // Wait at least n days before opening
        if (launchCount >= LAUNCHES_UNTIL_PROMPT && 
                System.currentTimeMillis() >= dateFirstlaunch + (DAYS_UNTIL_PROMPT * 24 * 60 * 60 * 1000)) {
            showRateDialog(editor);
        }
        editor.apply();
    }

    public void showRateDialog(final SharedPreferences.Editor editor) {
        AlertDialog.Builder builder = new AlertDialog.Builder(mContext);
        builder.setTitle("Rate " + APP_TITLE);
        builder.setMessage("If you enjoy using " + APP_TITLE + ", please take a moment to rate it. Thanks for your support!");
        builder.setPositiveButton("No", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialogInterface, int i) {
                editor.putBoolean("dontShowAgain", true);
                editor.apply();
                dialogInterface.dismiss();
            }
        });

        builder.setNegativeButton("Remind me later", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialogInterface, int i) {
                // Reset days and app launch count
                editor.putLong("launchCount", 0);
                editor.putLong("dateFirstLaunch", 0);
                editor.apply();
                dialogInterface.dismiss();
            }
        });

        builder.setNeutralButton("OK", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialogInterface, int i) {
                mContext.startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("market://details?id=" + APP_NAME)));
                editor.putBoolean("dontShowAgain", true);
                editor.apply();
            }
        });
        builder.show();
    }
}

We have to call the appLaunched() method in the MainActivity in the onCreate() method so that it can perform the launch count check every time the app is launched.

import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;

public class MainActivity extends AppCompatActivity {

    private RateAppUtil mRateAppUtil;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        mRateAppUtil = new RateAppUtil(this);
        mRateAppUtil.appLaunched();
    }
}

Access the code for the Rate App in the Alert Dialogs demo at Github.