fabiochiu/medium-articles huggingface dataset:
Data tracking with AI and OCR technologies
Tags: Corporate Insurance, Banks, Ocr Software, Documentation, Extracting Data

Data tracking with AI and OCR technologies

Overview

Building the workflow of tracking and processing data

using AI and OCR technologies.

As a matter of fact, insurance is an area with the largest number of time-consuming issues. Obviously, case management is one of the most popular tasks in this sector.

Our solution created to help the claims managers by providing the platform that will, on the one hand, automate the reading insurance claims, and on the other hand, will record all necessary information into a database or a table.

Challenge

Automate the process of claims management.

Extract and classify the data.

Solution

Implement connectors to determine specific cases of the claim.

Implement connectors for extracting and classifying the data.

Used connectors

…………………….

LUIS

Amazon Textract

Oracle

Workflow

……………

(1) Retrieving data from the company database.

(2) Extracting data using AWS Textract.

(3) Classifying data with LUIS

(4) Sending classified data

to the new database

(Oracle)

Result

……….
How to read code without documentation?
By: Wojciech Milewski
Tags: Documentation, Software Engineering, Software Development

Writing documentation is painful. You need to keep it in sync with your code, you need to draw nice graphs and diagrams, you need to do it for all 100 microservices. And if your Product Owner pushes you because the deadline is already missed, you may simply forget to write about one corner case. And it may hit you one year later, because “it was not in the documentation!”. And it may hit you hard. And it will.

What if you could never, ever write any documentation at all? But how can I understand code without documentation? Is it even possible?

Well, yes, and here are some tips for you.

Use end-to-end or acceptance¹ tests

Those tests show you responsibilities of an application. They show you the input — how to interact with an application, and the output — what you might expect as a result of the interaction.

Let’s say that you build a service responsible for creating and reading user’s tweets. There are two ways of interaction — you can either get all tweets or post a new one. End-to-end tests would look like:

There is only one input — POST method for adding tweets. You can observe the output of the interaction in GET method for reading tweets.

Thanks to that, you don’t have to document what an application does. It’s already documented (and always up to date) as tests.

Focus on points of integration with “external world”

Software is just a bunch of algorithms “connecting the dots”. The dots are — REST API, external services like Github API, a database used for storing some data or event bus for asynchronous communication. Start with an input (like REST API) and see the flow between the dots.

There are two “dots” — repository and eventPublisher . They are showing you where your data is passed to and what kind of side-effect you might expect. The rest is not so important — there are some corner cases, which don’t change the flow significantly.

This approach helps you to easily build a sequence diagram by yourself and understand how an application works.

Find and use patterns

It’s much easier to look at something similar you already know. We like the moment when we can say “I’ve seen that before!”. When you see usage of DDD, you expect that a Repository will be responsible for storage. When you see a Handle or a Controller you expect that it’s responsible for managing input.

All places related to REST API are named Controller . All places related to access to a database are named Repository . You might expect that other similar components will be named the same way.

How does that help? You don’t have to document the behaviour of those, because you know that already by convention and patterns.

Is that all?

No, of course not. But those three tactics are most helpful to me and actually, they helped me not to write any documentation and easily navigate through code.

¹Most of the time names end-to-end or acceptance means the same thing. Usually, it’s about black-box testing when you pass input and check for output result.
3 Must-Have attributes of Successful Product Managers
By: Eric Chan
Tags: Grit, Communication, Analytics, Product Management, Documentation

2. Communication and Documentation

Stakeholders management and alignment is an everyday thing for Product Managers. Rather than under-communicating and leaving people out (accidentally or intentionally), over-communicating is a good habit to have stakeholders informed regularly of ongoing initiatives and projects. Frequent communication has countless of benefits. Just to name a few. Firstly, it helps to build rapport and trust with teammates, being able to move towards the same goal together. Secondly, it helps to identify any red flags early. Stakeholders might not agree or understand the intent of the initiative, so involving them early will be helpful to identify misalignment risks before the scope of the initiative firms up.

Why communication and documentation are the same point is because they are complementary. A good PM will clearly document the product objectives and requirements and use that as a tool to communicate with stakeholders on why the product or initiative is worth chasing for. Also, the document can be the source of truth. There is no point documenting but not using that to communicate across. On the other side, it is inefficient communicating over a black piece of paper. In short, documentation work hand in hand with communication very well.
6 Proven Practices to write & manage PRDs like a Pro — (1)
By: Product Peas
Tags: Product, Task Management, Product Management, Documentation, Agile

Product Requirement Documents (PRDs) are necessary for every product/feature that needs to be developed. This one document forms the single source of truth about the product/features built. Also, this document will be referred by multiple teams and stakeholders at various stages of the product development process, and other important documents (tech document, test document, product manual, etc) will be churned out based on this document

That’s how important PRDs are for the entire team and company, and the ownership of this document lies with the Product Manager. So in this blog, we will talk about how the first proven practice to write & manage PRDs efficiently. This practice is the first step to creating professional PRDs that can be utilized by your team & stakeholders effortlessly

Proven Practice №1 — Use a standard PRD template

Using a standard PRD template every time you write a PRD will ensure that you have covered all the important things you need to write in the PRD, plus it is also easy for your team to navigate through your PRDs once they know the format

Ideally, your company should follow a standardized PRD template. But if that is not the case, especially with startups where the processes are not so defined, you can always propose PRD templates from your side and convince your Product Head/Founders to implement a standardized PRD template for the company

Here is a good PRD template that is simple and covers all the important sections that a PRD should have:
Generate a swagger documentation in laravel without PHPDoc or comment ? It’s possible
Tags: Laravel, Auto, Documentation, Swagger

Generate a swagger documentation in laravel without PHPDoc or comment ? It’s possible Mezatsong Jun 1·4 min read

A tutorial on how to get a Laravel API swagger documented with https://github.com/Mezatsong/laravel-swagger-docs

Laravel is a great php framework, with a lot of tools to facilitate the development of applications in PHP. However, despite all its qualities, it has the drawback of not having its own system for documenting APIs.

Usually laravel backend developers use external tools to document their API and this is a task that most hate doing.

In the vast majority of cases, developers will write the documentation themselves, whether through comments on functions or even outside the code, even if a minimum of comments is inevitable (eg: a simple string for description) to have a good documentation, there is usually too much to write besides the code to have a ready-made documentation and moreover you have to do maintenance on each change because it is not synchronized with the code.

In this article, I offer a half solution to this problem, using a package that will generate most of the documentation for us. We will not have to document our models, nor our requests. Due to the flexibility of the response types in the php functions, we will still have to document our responses.

Setup

Let’s start by creating new laravel application project using composer.

composer create-project --prefer-dist laravel/laravel my-api

In this tutorial I’ll assume you have a basic understanding of editing your hosts file, make sure to set APP_URL correctly because the package will use it, so we’ll serve our application straight on localhost for time’s sake.

cd my-api && php artisan my-api

CTRL+C to stop the server.
Reflecting on the first Coda Doctorate
By: Maria Marquis
Tags: Mariamarquis, Documentation, Coda, Learning, Startup

21 makers just graduated with our inaugural class, and I can’t stop smiling.

The Coda Doctorate is a five-week, asynchronous learning program with live elements — a blend of self-paced learning through video lessons, workbook exercises, weekly virtual office hours, and an active community Slack channel for conversations and support.

Here at Coda, we love to reflect, and all the time, energy, and work poured into the Doctorate deserves that consideration. Here are a few things our first Doctorate cohort taught me.

Technology is only as powerful as the people who use it.

Coda’s most powerful feature is the people who use it. The cohort was filled with people from all walks of life and experiences. We had students, teachers, theologians, product managers, singers, designers, marketers, parents, entrepreneurs, and people from all over the world.

We already see teams use Coda effectively for project management and wikis; the diversity of our Doctorate participates highlighted new ways to use Coda and provided invaluable feedback that is grounded in those unique experiences. A Coda doc can be a living thing — the physical representation of its maker’s mind. And, while I love a good project management tracker, I love seeing a person solve a unique problem (no matter how small!) for themselves, their family, their team, or the world.

We learn so much more when we do it together.

When we designed the program, we thought long and hard about structure. We wanted to ensure everyone could complete work on their own schedule (after all, we’ve got jobs, families, and hobbies!). The community Slack channel ended up being great for learning and asking questions, but the real benefit was making real human connections with our students and watching them step up to support each other. Our Slack channel had brilliant compassionate feedback, authentic cheerleading, and support when life crept in.

There’s no one right way to make.

I use Coda ALL THE TIME, and I’ve developed an approach that works for me, but Coda is what we all make of it. In every office hours session, we explored all the ways to solve a problem. This process helped me expand my skills but also ended up being inspiring for folks. Since there’s no one right way to make, there’s always more to try.

I also found that this allowed us to appreciate the variety of approaches in the room and made learning Coda less intimidating.

You don’t have to be a programmer to be a great Coda maker.

Sure, programmers can be great Coda makers. But that’s not a requirement. This cohort of Coda makers is full of amazing doc builders who’ve never touched C++ or Javascript in their life. Being a great Coda maker only requires 3 things:

A problem you are passionate about solving. Empathy for the people who will use your doc. Openness to explore and tinker.

Join the next Coda Doctorate cohort.

We have another cohort starting October 11, and if you would like to be notified of the application deadline, fill out this form. We would love to have you join the movement!
Documentation with KDoc for Kotlin/Android
By: Ali Shobeyri
Tags: Kotlin, Programming, Java, Android, Documentation

Think about you’re creating a library and you want to publish it on Git, or even you’re writing your casual code on some project, you need to write good documentation for other people too. what happens if someone wants to use your library or work beside you on an old project?

Here is KDoc, a language for writing documents for Kotlin code !!!

Similar to JavaDoc you the main format for KDoc is :

starting with /** and end with */.

In KDoc we can use tags, a tag formula is @tagname+ space +name (or sometimes just @tagname ), here is an example :

On the code above you can see :

first I write a summary about the foo function adding @param input so other programmers can understand what is input

Let’s see some famous tags :

@param => you can document a parameter of a function or generic type of a class or … :

as you can see we can use T or [T] (when you use [T] you can don’t use space after @param.

@propertity => document properties of constructor

@return => document what is the output of a function

@constructor => document what is the primary constructor

@throw + class => document what kind of exception will throw when something goes wrong

@see => add a link or method as a reference

@sample => show an example of code

you can find more tags on Kotlin website.

here is a good example :

It’s nice, right? remember the documentation should not be so long, just a summary of what is happening in this class would be enough.

Let’s move forward to the next step, using Dokka!

Dokka is a documentation engine for Kotlin, It can create better visual documentation for us.

Look at this picture:

Amazing!!! right?

Ok let’s see how we should create this, first we need to add these to Gradle:

classpath(“org.jetbrains.dokka:dokka-gradle-plugin:1.4.30”)

id ‘org.jetbrains.dokka’

after this enter this on terminal: gradlew.bat dokkaHtml (I believe ./gradlew for Linux/Mac) and after building you can find that on app\build\dokka.

Instead of dokkaHtml you can try dokkaGfm and dokkaJavadoc.

contact me: shobeyri.ali@gmail.com

my Linkedin : https://www.linkedin.com/in/iryebohs/
Wise Compassion Versus Idiot Compassion
By: Manus Wong
Tags: Boundaries, Relationships, Compassion, Advice, Kindness

To be compassionate is to reduce suffering. The suffering of others, as well as ourselves. However, in a bid to practice compassion towards others, we often add to our own suffering instead.

When people take advantage of our proclivity to be compassionate and consequently walk over us, the “compassion” we’re exercising isn’t genuine anymore. It’s no longer regarded as Wise Compassion. Rather, it’s more commonly referred to as Idiot Compassion.

Why we practice Idiot Compassion?

Our fear to avoid conflict is what usually triggers people to practice Idiot Compassion. No one wishes to present themselves as the antagonists in other people’s narratives. So, we opt for the easier choice — we allow them to trample over our heads, and get away with their actions.

The deeper and more subtle reason explaining our tendency to practice Idiot Compassion is our desire to escape our own feelings of inadequacy. We just cannot bear to see our friends and family suffer. So we give in to the voices inside of us which convince us it’s alright to “help” them. But in fact, this form of compassion is largely self-serving. It’s aimed at benefitting ourselves, not the person who’s really suffering. As such, we’ve to learn to focus on the larger picture, and not the short-term benefits we gain from giving in to what other people want.

How to AVOID practicing Idiot Compassion?

Practicing Wise Compassion takes courage. It requires us to discern the true motivations driving our actions. So the next time you’re reaching out to help someone, ask yourself these questions: who are you truly trying to help — the other person or yourself? If it’s the latter, how can I then redirect my focus to the other person instead? These questions shall guide you to make better judgements, and practice Wise Compassion, rather than Idiot Compassion.
What if all the countries decide to have no boundaries??
By: Suma R
Tags: Dream, Boundary

Oh what a thought what a thought!!

“Panchi nadiyan hawa ke jhonke koi sarhad na ise roke.” says a Hindi movie song means there is no boundary which can stop the flow of bird, river and breeze.

Photo by Matthias Götzke on Unsplash

As I was sipping my cup of coffee in the evening and listening to this song I had this dream and Imagined as if we have same thing applied for Human beings

The lovely things which can happen :

There will be love and harmony every where

All the conflicts between the countries would come to an end.

India and Pakistan would be one so as Israel and Palestine.

There will be no wars and People never ever have to live under the threat of nuclear bombs.

We can create more safe and secure place to live for our coming generation.

There would no need of Visa and Passport.

The confusions which can appear:

People will be totally confused.

Confusions all over because of the different rules and regulations of different countries.

Since there is no boundary there is no separate governments and there will be no regulations

There will be confusions in the languages and big chaos in the communication

Commerce went on a toss because there was no uniformity on the currency.

Photo by Nathan Dumlao on Unsplash

Uff!! all these things will definitely happen as these things are man made and man is conditioned follow the rules.

Suddenly the doorbell rang and I woke up from the dream and realized that

Though it looks like a beautiful and loving dream in reality its very very tough to accept and implemented into reality. Though there is war and unrest in the world there is still humanity lives if the above situation comes into reality people will definitely try to overpower each other and make this world more of a hell than a heaven.
Implementing Regression Using a Decision Tree and Scikit-Learn
By: Dhiraj K
Tags: Heartbeat, Decision Tree, Python, Data Science For Ml, Machine Learning

Introduction

Do you remember climbing trees in your childhood? According to researchers, at the University of North Florida, climbing a tree can dramatically improve cognitive skills, including memory. Climbing trees can help children become more flexible in body and mind, while also developing strong spatial reasoning skills.

As it turns out, “trees” can also help machines learn. As illustrated below, decision trees are a type of algorithm that use a tree-like system of conditional control statements to create the machine learning model; hence, its name.

In the realm of machine learning, decision trees algorithm can be more suitable for regression problems than other common and popular algorithms. Below are the cases where you would likely prefer a decision tree over other regression algorithms:

There are non-linear or complex relationships between features and labels You need a model that is easy to explain

Before we jump into an implementation of a decision tree for a regression problem, let’s define some key terms.

You may like to watch a video on Decision Tree from Scratch in Python

Decision trees: Key terms

Root Node: The top-most decision node in a decision tree.

The top-most decision node in a decision tree. Decision Node: A tree node or parent node that splits into one ore more child nodes is called a decision node.

A tree node or parent node that splits into one ore more child nodes is called a decision node. Leaf or Terminal Node: Bottom nodes that (generally speaking) don’t split any further.

Bottom nodes that (generally speaking) don’t split any further. Splitting : Process of dividing a node into two or more child nodes.

: Process of dividing a node into two or more child nodes. Pruning: The opposite process of splitting. Removing the child nodes of a decision node is called pruning.

Note that decision trees are typically plotted upside down, so that the root node is at the top and the leaf nodes are the bottom.

Decision tree algorithms can be applied to both regression and classification tasks; however, in this post we’ll work through a simple regression implementation using Python and scikit-learn.

Regression trees are used when the dependent variable is continuous.

For regression trees, the value of terminal nodes is the mean of the observations falling in that region. Therefore, if an unseen data point falls in that region, we predict using the mean value.

Photo by Alex Holyoake on Unsplash

Now let’s start our implementation using Python and a Jupyter notebook.

Once the Jupyter notebook is up and running, the first thing we should do is import the necessary libraries.
Decision Tree: build, prune and visualize it using Python
By: Gustavo Hideo
Tags: Decision Tree, Python, Data Science, Data Visualization, Machine Learning

Let’s get started!

Decision Tree Model

We will be using the Titanic data set from a Kaggle to predict survivors. We will import the data and select some features to work with. ‘Survived’ is our target value.

data = pd.read_csv(‘path_or_link/train.csv’)

data = data.loc[:,(‘Survived’,’Pclass’,’Sex’,’Age’,’SibSp’,’Parch’,’Fare’)]

sample of the data

Missing values

We have some missing values for ‘age’. To fix it, we could run some predictive analysis and fill up these spots, but that’s not the goal for this article, so we will let it for a future story. For now, let’s just drop those rows with missing values.

Encoding categorical features

To keep all the features in numeric format, we will encode the ‘Sex’, that means to transform the values from ‘female’ and ‘male’ to 0 and 1.

data.dropna(inplace=True)

#'inplace=True' applies the code to the 'data' object. from sklearn.preprocessing import LabelEncoder

le = LabelEncoder()

data.Sex = le.fit_transform(data.Sex)

Splitting data set into train and test sets

x = data.iloc[:,1:] # Second column until the last column

y = data.iloc[:,0] # First column (Survived) is our target from sklearn.model_selection import train_test_split

#this function randomly split the data into train and test sets x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=.3)

#test_size=.3 means that our test set will be 30% of the train set.

Building the decision tree classifier

DecisionTreeClassifier() from sklearn is a good off the shelf machine learning model available to us. It has fit() and predict() methods.

The fit() method is the “training” part of the modeling process. It finds the coefficients for the algorithm. Then, the predict() method will use the trained model to make predictions on a new set of data (test set).

dtree = DecisionTreeClassifier()

dtree.fit(x_train, y_train) #train parameters: features and target

pred = dtree.predict(x_test) #parameter: new data to predict

Accuracy

To determine how good our model is, we use another package from sklearn to give it a measure:

from sklearn.metrics import accuracy_score

accuracy_score(y_test, pred) #parameters: targets to be predicted and predictions from new data used before

Accuracy: 0.75

It means that we have 75% accuracy in our predictions.
All About Decision Trees Part :- I
By: Gaurav Kumar
Tags: Classification Algorithms, Decision Tree, Data Science, Artificial Intelligence, Machine Learning

Source:- scikit-learn

Decision Tree is a famous Machine Learning Algorithm which is used in both Regression and Classification problem.

This algorithm works by making the statement of a choice and based on its results whether True or False provides different conclusion.

Below is the diagram of a very basic decision tree.

Basic Decision Tree

By default in a decision tree usually when the condition is True, then the sub branch is shown on the left and when the condition is False the it is shown on the right.

So, if you are provided with True/False written in the diagram, you can consider the default directions.

Basic Terminologies related to Decision Trees:

Root Node:- This is the beginning node of the tree after which whole population splits based on different features. Branch Node:- This is the node below the root node which splits further. In the flowchart, a branch node is one on which arrows are both pointing and moving away. Leaf Node:- The node which can’t be split further to make decisions is the leaf node. In the flowchart, it is the node on which arrows are pointing, but there are no arrows pointing away from it.

The below picture can help you understand about these parts of the tree.

With respect to the target variable, there are two types of decision trees:

Regression Trees: When the target/dependent variable is a continuous numeric variable, then the decision tree used to predict that numeric feature is called Regression Tree. Classification Trees: When the target/dependent variable is discrete categorical variable then the decision tree used to predict that target feature is called Classification Tree.

Example of both kind of trees is given below:
Entropy and Gini Index In Decision Trees
By: Naftal Teddy Kerecha
Tags: Entropy, Gini Index, Decision Tree

Entropy

As mentioned above entropy is one method used to partition a decision tree into smaller subsets, by partitioning the tree it acts as a threshold value for a tree node. Entropy is the measure of the impurity of a set of data alternatively we can think of this as the measure of the disorder or uncertainty of a group.

The formula used to determine entropy

Intuitively, entropy is the sum of the probability of a value occurring multiplied by the log of that probability occurring to the base two. Since probability falls in the range of 0–1 the summed value will always be negative thus it needs to be multiplied by -1.

Let's understand this better using an example: Say we have data from a furniture store regarding certain products and whether they sold

Furniture Store Data

Find the entropy of the Status variable: Let us assign dummy variables to the Status variable — Sold(1) and In-Store(0).

As expected for the Status feature we have high entropy which implies a high level of uncertainty. If were to increase the number of sold items and reduce the number of In-store status items to say 1 then we are reducing the level of uncertainty and thus increasing the purity level.

The highest level of impurity for a set of data is achieved when there is an equal or an almost equal division of the unique values in the set of data. This can be visualized as follows:

Relationship of Entropy and Probability

If a set of data has a uniform distribution then it follows that all values will have the same probability of occurring and as a result, the entropy is always maximized for each value in the uniform distribution.
Decision Trees: Essential Things to Know
By: Praveen Pareek
Tags: Interview Preparation, Interview Questions, Decision Tree, Algorithms, Machine Learning

Basic Terminologies

Entropy

A decision tree is built top-down from a root node and involves partitioning the data into subsets that contain instances with similar values (homogenous).

The algorithm uses entropy to calculate the homogeneity of a sample.

If the sample is completely homogeneous the entropy is zero and if the sample is an equally divided it has entropy of one.

Information Gain

We can define information gain as a measure of how much information a feature provides about a class.

Information gain helps to determine the order of attributes in the nodes of a decision tree.

The main node is referred to as the parent node, whereas sub-nodes are known as child nodes.

We can use information gain to determine how good the splitting of nodes in a decision tree.

Article: Entropy and Information Gain to Build Decision Trees

Gini Impurity

The internal working of both methods is very similar and both are used for computing the feature/split after every new splitting.

But if we compare both the methods then Gini Impurity is more efficient than entropy in terms of computing power.
Decision Tree Regression and Classification in Machine Learning
Tags: Data Science, Machine Learning, Decision Tree, Machine Learning Python

What is Decision Tree?

Decision Tree is used to solve Regression and classification problems via Tree based methods using Root nodes,edges, decision node and leaf with different technicques for a given data set.

Decision Tree algoritham is one of the most important algoritham in machine learning which can be used in ensamble technicque especially bagging and boosting technicques.



How Decision Tree will be formed to predict the output?

The following technicques will be used When the data set is given to identify the output of a given Regression or classification problem.

1.Entropy

2.Information gain

3.Gini impurity or Gini Index.

To form a tree the below form of tree will be used

1.Root Node

2.Edge

3.Decision Node

4.Leaf

The below pictorial representaion will explain in simple way to understand the structure of Decision Tree model.

Lets start with a example in order to understand how Decison Tree Model will work to predict ouput of given data set.

I will use the famous example given to students in most of the websites to understand easily. To begin with example, Let me start with what is entropy.



Entropy: Entropy is the first step of identify the purity of data set. Entropy is some what complex logic to identify the purity of the data set because this

ID3 algoritham would use log function to predict the purity of data set.

Data set is pure and Decision Tree is perfect when entropy value is 0 where as Data set is impure and identified Decision tree is invalid.

The below given formula is used to identify Entropy.

Information Gain: Information gain is also used to form a best Decision Tree model along with the Entropy. Information Gain will use entropy

values to find best fit of the Decisoon Tree with reduced entropy values. The below formula and examples would be used to identify the Best deceion node.

Step 1: Calculate entropy of the target.

Step 2: The dataset is then split on the different attributes. The entropy for each branch is calculated. Then it is added proportionally, to get total entropy for the split. The resulting entropy is subtracted from the entropy before the split. The result is the Information Gain, or decrease in entropy.

Step 3: Choose attribute with the largest information gain as the decision node, divide the dataset by its branches and repeat the same process on every branch.

Step 4a: A branch with entropy of 0 is a leaf node.

Step 4b: A branch with entropy more than 0 needs further splitting.

Step 5: The ID3 algorithm is run recursively on the non-leaf branches, until all data is classified.

Gini Impurity: Gini impurity is similar to Entropy.Formula is different to identfy the correct nodes. Gini impurity is better than Entropy because the computational speed is very high.
Reviewing the TensorFlow Decision Forests library
By: Parul Pandey
Tags: Random Forest, Decision Tree, Data Science, TensorFlow, Machine Learning

Reviewing the TensorFlow Decision Forests library

Thanks to https://undraw.co/illustrations for providing free illustrations

In their paper, Tabular Data: Deep Learning is Not All You Need, the authors argue that while deep learning methods have shown tremendous success in the image and text domains, traditional tree-based methods like XGBoost still continue to shine when it comes to tabular data. The authors examined Tabnet, Neural Oblivious Decision Ensembles (NODE), DNF-Net, and 1D-CNN deep learning models and compared their performance on eleven datasets with XGBoost.

Tabular Data: Deep Learning is Not All You Need | source: https://arxiv.org/pdf/2106.03253.pdf

This is an important paper in the sense that it reiterates that deep learning may not be the silver bullet for solving all machine learning problems. On the other hand, tree-based algorithms have been shown to perform at par or even outperform neural networks for tabular data while being simple to use and comprehend.

And there is good news for people who like to work with tree-based models. A few months back, the TensorFlow Decision Forests, aka TF-DF library, was open-sourced by Google. In this article, we’ll understand what TF-DF is and how it could be helpful for us.
Working behind DECISION TREES — Easy Explanation
By: Sukriti Macker
Tags: Data Science, Data, Machine Learning, Decision Tree

HOW THE NODE & HOW DO WE KNOW WHICH FEATURE TO SPLIT THE NODE ON?

To select the feature for the split, we calculate the impurity of the node. We want to select the feature which gives us the lowest impurity.

Lowest impurity means that the split will produce “less” impure nodes.

The aim is to reach pure nodes, where each node belongs to a single output class.

How do we calculate impurity?

The most common method is GINI INDEX. It is used for binary split, that is, for an output which has two classes only. Other measures include:-

Accuracy Information Gain Gain Ratio

Let’s focus on GINI INDEX to understand the concept of splitting the node using a feature.

How do we calculate Gini Index?

Gini Index = 1- square of(Probability of “Yes”)- square of(Probability of “No)

Formula for Gini Index

Let us now take a dataset to understand how to choose the feature to split the node on?

We have a dataset with Independent Variables or Features such as Chest Pain, Good Blood Circulation & Blocked Arteries, determining whether the person has a Heart Disease or not. Heart Disease is our target class or a dependent variable. Therefore, the dataset has the target classes as Yes or No.

Sample Dataset

In the dataset above, we have four features: Chest Pain, Good Blood Circulation & Blocked Arteries. Out of the four features, we can make any one as the root node. To decide which node to make the root, we calculate the Gini Index and pick the lowest impurity feature.

Assume, we pick Chest Pain as the root node feature:-

If Chest Pain is YES -> 105 People have Heart Disease, and 39 don’t have Heart Disease.

If Chest Pain is NO -> 34 People have Heart Disease, and 125 don’t have Heart Disease.

Possible candidates (features) for the position of ROOT NODE.

Now, calculating Gini Index for Chest Pain Feature:-

Gini Index for when Chest Pain is YES = 1- square of(Probability of Heart Disease Yes)- square of(Probability of Heart Disease No)

= 1- square of(105/105+39)- square of(39/105+39)

= 0.395
More Than Being a Host: COUCHSURFING!
By: Nida Icyer
Tags: Culture, Couchsurfing, Host, Tradition, Travel

Can an application change your life?

Yes, Couchsurfing has been changing my life. If somebody asks me about my hobbies in a job interview, the answer is definitely CouchSurfing. Do not tell me an application is not a hobby! I am going to tell you:)

So what is the COUCHSURFING? Couchsurfing is a service that connects members to a global community of travelers. Use Couchsurfing to find a place to stay or share your home and hometown with travelers but it is more than this definition for me.

Topkapı Palace / My lovely Indian guests / 2008

I have always love to meet with foreigners, learn their culture and tradition since I was a child (no matter where they are from). I have been to the USA, Indonesia, and Serbia. However, there are still more than 190 counties where I have not been yet. So what can I do sometimes?:) Sometimes reading the travel blog and watching videos is not enough to explore their culture. If you can not go to those all counties, their citizens drop in your lap in your county. The problem is how can you find them. That’s where Couchsurfing comes into play.

My guests from New Zealand, India, Japan, China, Indonesia, Singapore and so on❤

Even if I can not host people, I like to have a Turkish dinner with them by sharing our stories and cultures. I have met people from 15 different countries since 2019, October and I continue to meet.

When I share the story of what I realized from their culture on Instagram, many people have told me you should have a YouTube channel. However, I am not good at about video editing and I prefer writing. That’s where Medium is a good place to share what I write.

I have decided to write Medium Series about CULTURES by using my lovely favorite app Couchsurfing. This is just an entry and introduction about Couchsurfing and my future Medium plans:) It will not be a travel blog or tourist travel guide, only smells CULTURES.

Looking forward to sharing my first story about Indonesian Culture next week:)

With lots of loves ❤

Nida

NOTE: I am sorry for my English mistakes. I strongly believe that we will improve my poor English together:))
'Shakha Pola' :Traditional bengali bangles Just like the tradition of wearing the ‘Chooda’ amongst…
By: Meher Bose
Tags: Indian, Marriage, Custom, Tradition, Bengali

'Shakha Pola' :Traditional bengali bangles

Just like the tradition of wearing the ‘Chooda’ amongst Punjabis’, Bengali brides are bound by the age old custom of donning their hands with a pair of red and white bangles, known as the ‘Shakha Pola’. However similar the two may be, the former are worn in a count of 21 . The bride is supposed to wear these 21 plastic or ivory based ornaments for a period of 15month or 40 days which is believed to secure and strengthen her marital bond with her husband.

The cultural variant to the ‘Chooda’ , is the Bengali ‘Shakha pola’. One being an intricately carved out white bangle made of conch shell and the other , a bright red bangle made of coral. Both hold the same symbolism as the ‘Chooda’, yet to be worn together with a ‘loha’ or iron based bangle. There is a peculiar folklore attached to wearing these bangles. It is said that they distinguish her from her father’s clan or kula , the very moment she dons them on the day of her marriage. After which she is part of her husband’s clan for the rest of her life. The ‘Shakha Pola’ is also known as the ivory of the poor and was historically carved out by fisherman’s wives from the shells they received from their husbands as gifts. The ‘Shakha Pola’ ceremony or ‘Dodhi Mangal’ is one of the crucial rituals of a bengali marriage in which 7 married women bless the bride by donning her hands with these auspicious bangles. Thus symbolizing the blessings of 7 goddesses upon her happy married life.

However significant these bangles may be for a Bengali bride, today she would rather live without them as much as she would live without , the ‘Sindoor’ or even the ‘Mangalsutra’. Such accessories, tend to overpower her womanly existence in the garb of being the building blocks of her marriage. She does not want to be objectified or bogged down by the cultural components associated with marriage. Thus really proving how ornaments have become a mere form of accessory for the modern bengali and Indian bride, than being a significant part of her cultural existence.

Pic credits-:

https://pin.it/v6u5aCF

Information credits-:

https://shormistha4.blogspot.com/2018/08/why-do-married-bengali-women-wear.html

https://timesofindia.indiatimes.com/blogs/pluto-mom/my-shakha-pola-santa-bangles/

https://www.shaadidukaan.com/blog/significance-of-bangles-for-indian-brides.html
The Unculture Manifesto
By: Unculture Media
Tags: Culture, Family, Tradition, Manifesto, Philosophy

Unculture is anything useful or enjoyable that culture leaves behind.

It is the mysterious garden from which our institutions bloom, namely:

The Church

The Family

The School

It is the fuel propelling these bones of civilization, the set of life-giving ideas, emotions and activities that animate society. It stands outside the bounds of ephemeral culture, because it precipitates culture.

All counter-culture opposes culture, and therefore the institutions, and therefore the Unculture from which they all arise. But Unculture has no interest in resisting the counter-culture, because Unculture is incontrovertible.

While every revolution begets a counter-revolution, Unculture sits beyond the limits of that vicious cycle. It encompasses only traditions molded by the fires of time, not destroyed, conducive to family, church and school:

Eating

Drinking

Singing

Dancing

Praying

Gardening

Reading

Laughing

Working

Talking

Celebrating

To live happily, we must adopt Unculture in place of our ever-fragmenting set of cultures and counter-cultures. Instead of rebelling against our foundations, we must rebel against our self-destruction.

Not only does Unculture aid our survival, it grants a much simpler life than keeping with the latest trends. It sets our perspective on matters that last. We rest easy, obtaining a happiness that does not fade with every sunset. We feel pride in our work. We watch our children grow and do the same.

With Unculture Media, we want to provide you a place on the Internet free of slippery rhetoric. Instead of frivolous factoids, we want you to be edified by the scaffolding of American culture: faith, merit and free dialogue.

We will cover workers and thinkers from all walks of life, believing that:

Hard work pays off

Gains are good

Funny is funny

Holy things are for the holy

If any of that grabs your attention…

Sign up for our newsletter at UncultureMedia.com…
The sham of a company called Rentickle
By: Ayush Sharma
Tags: Customer Success, Customer Service, Shared Economy, Rental

The tale of pathetic customer service from a five year old consumer-facing furniture renting platform with 4 million USD in funding.

Tony Hsieh, the founder of Zappos, a company known for its excellent customer service once said, “Zappos is a customer service company that just happens to sell shoes.” Operating in a crowded space with players like Furlenco, RentoMojo, GrabOnRent, and Cityfurnish to name a few, one would hope folks at Rentickle would take this advice very seriously. But no, they couldn’t seem to care less.

As amusing as it is for a consumer-facing brand to not have a Twitter account, a simple search for ‘rentickle’ results in this:

On 1st Feb, I placed an order of a considerable amount for a bunch of things on Rentickle. I picked them on the basis of the competitive prices they offer and seemingly nice furniture. What followed was two weeks (and counting) of umpteen number of unanswered calls, unresolved queries, and an ever-elusive delivery date.

Order placed on 1st Feb 2020

Since then this is what I have been through to get an update on delivery from Rentickle.
5 Keys to Knowledge Base Adoption
By: Lauren Taylor
Tags: Customer Support, Thought Leadership, Help, Customer, Customer Success

You’ve invested time, resources, and manpower into creating a knowledge base to support your users. Unfortunately, support tickets continue to rise while articles remain unvisited. The struggle of providing help to users and getting them to use it… is real!

No fear, all is not lost, just have agents hyperlink to the knowledge base article when they are responding — conditioning the customer to go to the Knowledgebase for future answers. A critical piece of this puzzle is having a solid knowledge base to be able to start increasing adoption with your users!

Let me share our 5 keys to increasing your knowledge base adoption.

Searchable Content: No one likes endlessly searching. A user searching for help is already frustrated & short on time, make content easy to find. Relatable Content: Have you ever gone to search for a particular document and all the “help documentation” was information no one cares about? It’s frustrating! Be sure that help articles are relatable to the majority of your users. Up-to-Date Content: Users love to see updates & enhancements in a product — it’s exciting & builds pride in the product. However, this can quickly become a pitfall & frustration for your users if documentation fails to remain updated. Accessible Content: It’s pretty standard to have a knowledge base site outside of the application in need of support. It’s crucial to provide many points of contact that direct the user to the Knowledgebase. Making the content easily accessible for users to find when they are in a pinch. Understandable Content: You’ve been there… after trying numerous searches the article is hard to follow. One might print it in hopes it's easier to follow step by step to complete the process. These articles need to be easily readable & consumable. If too many words, no visuals, or too lengthy, you’ll lose the opportunity to assist your users through the knowledge base.

That’s it in a nutshell. Just remember — turn support tickets into KB articles, link KB articles in ticket responses, and of course our 5 keys to adoption. If you follow this guideline, you’ll be a support ninja in no time.
Predictability of possible churns. How do we do it?
Tags: Product Management, SaaS, Customer Success, Churn Prediction, Software

We have the light at the end of the tunnel!

Anallytica was born with the goal of helping companies build better software and make their users love it! Our purpose goes beyond monitoring NPS, DAU/MAU, and engagement data: we know the behavior of your users and know the health of each of them.

Each user within Anallytica has their own score that is updated in real-time based on 3 indicators vs. a weight each has. These are days of not accessing the software, NPS note, and events within your product (this has an essential role in this quality of the foundation and you can understand a little more about it in this link).

Based on behaviors set by you we understand which customers are likely to cancel or not and show you this on a priority list about which to approach first. And the coolest: if set up correctly, we also show this information with the value of MRR next door, so you prioritize users who pay more!

And with this information in hand, we also know which users are super engaged with you — a super opportunity for an upsell! :)

And when we talk about predictability, we want to be assertive indeed!

The health of your base has been working since day 1 of Anallytica — and with that, you can already turn on the light of the room on everything that happens to your active user base. But we want more!

We are building functionality to capture all of your churned users (whether retroactive or today).

With this, we will understand the key behaviors that caused that user to cancel, to understand what pattern of behavior leads a user to this. So when a new user achieves this bad behavior the grade of it slows down dramatically and it gets a priority on your list!

And this is simple to set up!

If you as an Anallytica user are already monitoring the events, you already have the health function of the base available to you. We want you to build better products, that your users love, and that mostly stay with you. May they are promoters and that by referral basis, bring you new and good deals!