1616049120

Inthe field of agriculture, the plants are closely observed in order to get the maximum yield. This includes observing various plant phenotypes such as flowers, leaves, stem length etc. These phenotypes indicate the growth of the plants under observation. Hence, appropriate care can be taken according to the observed growth and condition of the plant. This phenotype data is also useful for plant breeding and other related research programs. Counting leaves is one of the important phenotypes that gives a clear idea of the plant’s health and its current development stage. The traditional manual observation of these phenotypes can be a very slow and tedious. In order to automate this, we can use Image processing and Deep Learning techniques. This blog post aims at explaining the approach to solve one such scenario where we use Deep Learning and Image processing to count the leaves given the plant images in order to reduce the tedious task of manual observation.

Case Study Overview

The approach to this problem can be broken down into following steps:

- Problem Description
- Data Preprocessing
- Segmentation Model
- Regression Models based on Segmentation model
- Transfer Learning Models
- Results Analysis
- Model Quantization
- Streamlit App to demonstrate the Best Model
- Future Work/Improvements
- Conclusion

#deep-learning #segmentation #image-processing #keras #tensorflow

1678051620

In this article, learn about Machine Learning Tutorial: A Practical Guide of Unsupervised Learning Algorithms. Machine learning is a fast-growing technology that allows computers to learn from the past and predict the future. It uses numerous algorithms for building mathematical models and predicting future trends. Machine learning (ML) has widespread applications in the industry, including speech recognition, image recognition, churn prediction, email filtering, chatbot development, recommender systems, and much more.

Machine learning (ML) can be classified into three main categories; supervised, unsupervised, and reinforcement learning. In supervised learning, the model is trained on labeled data. While in unsupervised learning, unlabeled data is provided to the model to predict the outcomes. Reinforcement learning is feedback learning in which the agent collects a reward for each correct action and gets a penalty for a wrong decision. The goal of the learning agent is to get maximum reward points and deduce the error.

In unsupervised learning, the model learns from unlabeled data without proper supervision.

Unsupervised learning uses machine learning techniques to cluster unlabeled data based on similarities and differences. The unsupervised algorithms discover hidden patterns in data without human supervision. Unsupervised learning aims to arrange the raw data into new features or groups together with similar patterns of data.

For instance, to predict the churn rate, we provide unlabeled data to our model for prediction. There is no information given that customers have churned or not. The model will analyze the data and find hidden patterns to categorize into two clusters: churned and non-churned customers.

Unsupervised algorithms can be used for three tasks—clustering, dimensionality reduction, and association. Below, we will highlight some commonly used clustering and association algorithms.

Clustering, or cluster analysis, is a popular data mining technique for unsupervised learning. The clustering approach works to group non-labeled data based on similarities and differences. Unlike supervised learning, clustering algorithms discover natural groupings in data.

A **good clustering** method produces high-quality clusters having high intra-class similarity (similar data within a cluster) and less intra-class similarity (cluster data is dissimilar to other clusters).

It can be defined as the grouping of data points into various clusters containing similar data points. The same objects remain in the group that has fewer similarities with other groups. Here, we will discuss two popular clustering techniques: K-Means clustering and DBScan Clustering.

K-Means is the simplest unsupervised technique used to solve clustering problems. It groups the unlabeled data into various clusters. The K value defines the number of clusters you need to tell the system how many to create.

K-Means is a centroid-based algorithm in which each cluster is associated with the centroid. The goal is to minimize the sum of the distances between the data points and their corresponding clusters.

It is an iterative approach that breaks down the unlabeled data into different clusters so that each data point belongs to a group with similar characteristics.

K-means clustering performs two tasks:

- Using an iterative process to create the best value of K.
- Each data point is assigned to its closest k-center. The data point that is closer to the particular k-center makes a cluster.

An illustration of K-means clustering. Image source

“DBScan” stands for “Density-based spatial clustering of applications with noise.” There are three main words in DBscan: density, clustering, and noise. Therefore, this algorithm uses the notion of density-based clustering to form clusters and detect the noise.

Clusters are usually dense regions that are separated by lower density regions. Unlike the k-means algorithm, which works only on well-separated clusters, DBscan has a wider scope and can create clusters within the cluster. It discovers clusters of various shapes and sizes from a large set of data, which consists of noise and outliers.

There are two parameters in the DBScan algorithm:

**minPts**: The threshold, or the minimum number of points grouped together for a region considered as a dense region.

**eps(ε): **The distance measure used to locate the points in the neighborhood.

An illustration of density-based clustering. Image Source

An association rule mining is a popular data mining technique. It finds interesting correlations in large numbers of data items. This rule shows how frequently items occur in a transaction.

Market Basket Analysis is a typical example of an association rule mining that finds relationships between items in the grocery store. It enables retailers to identify and analyze the associations between items that people frequently buy.

Important terminology used in association rules:

**Support**: It tells us about the combination of items bought frequently or frequently bought items.

**Confidence**: It tells us how often the items A and B occur together, given the number of times A occurs.

**Lift**: The lift indicates the strength of a rule over the random occurrence of A and B. For instance, A->B, the life value is 5. It means that if you buy A, the occurrence of buying B is five times.

The Apriori algorithm is a well-known association rule based technique.

The Apriori algorithm was proposed by R. Agarwal and R. Srikant in 1994 to find the frequent items in the dataset. The algorithm’s name is based on the fact that it uses prior knowledge of frequently occurring things.

The Apriori algorithm finds frequently occurring items with minimum support.

It consists of two steps:

- Generation of candidate itemsets.
- Removing items that are infrequent and don’t fulfill the criteria of minimum support.

In this tutorial, you will learn about the implementation of various unsupervised algorithms in Python. Scikit-learn is a powerful Python library widely used for various unsupervised learning tasks. It is an open-source library that provides numerous robust algorithms, which include classification, dimensionality reduction, clustering techniques, and association rules.

Let’s begin!

Now let’s dive deep into the implementation of the K-Means algorithm in Python. We’ll break down each code snippet so that you can understand it easily.

First of all, we will import the required libraries and get access to the functions.

```
#Let's import the required libraries
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
```

The dataset is taken from the kaggle website. You can easily download it from the given link. To load the dataset, we use the **pd.read_csv() **function. **head()** returns the first five rows of the dataset.

*my_data = pd.read_csv('Customers_Mall.csv.')*
*my_data.head()
**
*

The dataset contains five columns: customer ID, gender, age, annual income in (K$), and spending score from 1-100.

The **info()** function is used to get quick information about the dataset. It shows the number of entries, columns, total non-null values, memory usage, and datatypes.

*my_data.info()*

To check the missing values in the dataset, we use **isnull().sum(), which** returns the total number of null values.

```
#Check missing values
my_data.isnull().sum()
```

The **box plot** or **whisker plot** is used to detect outliers in the dataset. It also shows a statistical five number summary, which includes the minimum, first quartile, median (2nd quartile), third quartile, and maximum.

*my_data.boxplot(figsize=(8,4))
**
*

Using Box Plot, we’ve detected an outlier in the annual income column. Now we will try to remove it before training our model.

```
#let's remove outlier from data
med =61
my_data["Annual Income (k$)"] = np.where(my_data["Annual Income (k$)"] >
120,med,my_data['Annual Income (k$)'])
```

The outlier in the annual income column has been removed now to confirm we used the box plot again.

*my_data.boxplot(figsize=(8,5))
**
*

A histogram is used to illustrate the important features of the distribution of data. The **hist()** function is used to show the distribution of data in each numerical column.

*my_data.hist(figsize=(6,6)) *

The correlation heatmap is used to find the potential relationships between variables in the data and to display the strength of those relationships. To display the heatmap, we have used the **seaborn** plotting library.

*plt.figure(figsize=(10,6))*
*sns.heatmap(my_data.corr(), annot=True, cmap='icefire').set_title('seaborn')*
*plt.show()
**
*

The **iloc()** function is used to select a particular cell of the data. It enables us to select a value that belongs to a specific row or column. Here, we’ve chosen the annual income and spending score columns.

*X_val = my_data.iloc[:, 3:].values*
*X_val
*

```
# Loading Kmeans Library
from sklearn.cluster import KMeans
```

Now we will select the best value for K using the **Elbow’s method. **It is used to determine the optimal number of clusters in K-means clustering.

```
my_val = []
for i in range(1,11):
kmeans = KMeans(n_clusters = i, init='k-means++', random_state = 123)
kmeans.fit(X_val)
my_val.append(kmeans.inertia_)
```

The **sklearn.cluster.KMeans()** is used to choose the number of clusters along with the initialization of other parameters. To display the result, just call the variable.

*my_val
**
#Visualization of clusters using elbow’s method*
*plt.plot(range(1,11),my_val)*
*plt.xlabel('The No of clusters')*
*plt.ylabel('Outcome')*
*plt.title('The Elbow Method')*
*plt.show()
**
*

Through Elbow’s Method, when the graph looks like an arm, then the elbow on the arm is the best value of K. In this case, we’ve taken K=3, which is the optimal value for K.

*kmeans = KMeans(n_clusters = 3, init='k-means++')*
*kmeans.fit(X_val)
*
*#To show centroids of clusters *
*kmeans.cluster_centers_
*
#Prediction of K-Means clustering
y_kmeans = kmeans.fit_predict(X_val)
y_kmeans

The scatter graph is used to plot the classification results of our dataset into three clusters.

```
plt.scatter(X_val[y_kmeans == 0,0], X_val[y_kmeans == 0,1], c='red',s=100)
plt.scatter(X_val[y_kmeans == 1,0], X_val[y_kmeans == 1,1], c='green',s=100)
plt.scatter(X_val[y_kmeans == 2,0], X_val[y_kmeans == 2,1], c='orange',s=100)
plt.scatter(kmeans.cluster_centers_[:,0], kmeans.cluster_centers_[:,1], s=300, c='brown')
plt.title('K-Means Unsupervised Learning')
plt.show()
```

To implement the apriori algorithm, we will utilize “The Bread Basket” dataset. The dataset is available on Kaggle and you can download it from the link. This algorithm suggests products based on the user’s purchase history. Walmart has greatly utilized the algorithm to recommend relevant items to its users.

Let’s implement the Apriori algorithm in Python.

To implement the algorithm, we need to import some important libraries.

```
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns
```

The dataset contains five columns and 20507 entries. The **data_time** is a prominent column and we can extract many vital insights from it.

*my_data= pd.read_csv("bread basket.csv")*
*my_data.head()
**
*

Convert the **data_time** into an appropriate format.

```
my_data['date_time'] = pd.to_datetime(my_data['date_time'])
#Total No of unique customers
my_data['Transaction'].nunique()
```

Now we want to extract new columns from the **data_time **to extract meaningful information from the data.

```
#Let's extract date
my_data['date'] = my_data['date_time'].dt.date
#Let's extract time
my_data['time'] = my_data['date_time'].dt.time
#Extract month and replacing it with String
my_data['month'] = my_data['date_time'].dt.month
my_data['month'] = my_data['month'].replace((1,2,3,4,5,6,7,8,9,10,11,12),
('Jan','Feb','Mar','Apr','May','Jun','Jul','Aug',
'Sep','Oct','Nov','Dec'))
```

*#Extract hour*

*my_data[‘hour’] = my_data[‘date_time’].dt.hour*

*# Replacing hours with text*

*# Replacing hours with text*

*hr_num = (1,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23)*

*hr_obj = (‘1-2′,’7-8′,’8-9′,’9-10′,’10-11′,’11-12′,’12-13′,’13-14′,’14-15’,*

* ’15-16′,’16-17′,’17-18′,’18-19′,’19-20′,’20-21′,’21-22′,’22-23′,’23-24′)*

*my_data[‘hour’] = my_data[‘hour’].replace(hr_num, hr_obj)*

*# Extracting weekday and replacing it with String *

*my_data[‘weekday’] = my_data[‘date_time’].dt.weekday*

*my_data[‘weekday’] = my_data[‘weekday’].replace((0,1,2,3,4,5,6), *

* (‘Mon’,’Tues’,’Wed’,’Thur’,’Fri’,’Sat’,’Sun’))*

*#Now drop date_time column*

*my_data.drop(‘date_time’, axis = 1, inplace = True)*

After extracting the date, time, month, and hour columns, we dropped the **data_time **column.

Now to display, we simply use the head() function to see the changes in the dataset.

*my_data.head()*

*# cleaning the item column*

*my_data[‘Item’] = my_data[‘Item’].str.strip()*

*my_data[‘Item’] = my_data[‘Item’].str.lower()*

*my_data.head()*

To display the top 10 items purchased by customers, we used a **barplot()** of the **seaborn** library.

```
plt.figure(figsize=(10,5))
sns.barplot(x=my_data.Item.value_counts().head(10).index, y=my_data.Item.value_counts().head(10).values,palette='RdYlGn')
plt.xlabel('No of Items', size = 17)
plt.xticks(rotation=45)
plt.ylabel('Total Items', size = 18)
plt.title('Top 10 Items purchased', color = 'blue', size = 23)
plt.show()
```

From the graph, coffee is the top item purchased by the customers, followed by bread.

Now, to display the number of orders received each month, the **groupby()** function is used along with **barplot()** to visually show the results.

mon_Tran =my_data.groupby('month')['Transaction'].count().reset_index() mon_Tran.loc[:,"mon_order"] =[4,8,12,2,1,7,6,3,5,11,10,9] mon_Tran.sort_values("mon_order",inplace=True) plt.figure(figsize=(12,5)) sns.barplot(data = mon_Tran, x = "month", y = "Transaction") plt.xlabel('Months', size = 14) plt.ylabel('Monthly Orders', size = 14) plt.title('No of orders received each month', color = 'blue', size = 18) plt.show()

To show the number of orders received each day, we applied **groupby() **to the weekday column.

```
wk_Tran = my_data.groupby('weekday')['Transaction'].count().reset_index()
wk_Tran.loc[:,"wk_ord"] = [4,0,5,6,3,1,2]
wk_Tran.sort_values("wk_ord",inplace=True)
plt.figure(figsize=(11,4))
sns.barplot(data = wk_Tran, x = "weekday", y = "Transaction",palette='RdYlGn')
plt.xlabel('Week Day', size = 14)
plt.ylabel('Per day orders', size = 14)
plt.title('Orders received per day', color = 'blue', size = 18)
plt.show()
```

We import the **mlxtend** library to implement the association rules and count the number of items.

```
from mlxtend.frequent_patterns import association_rules, apriori
tran_str= my_data.groupby(['Transaction', 'Item'])['Item'].count().reset_index(name ='Count')
tran_str.head(8)
```

Now we’ll make a mxn matrix where m=transaction and n=items, and each row represents whether the item was in the transaction or not.

```
Mar_baskt = tran_str.pivot_table(index='Transaction', columns='Item', values='Count', aggfunc='sum').fillna(0)
Mar_baskt.head()
```

We want to make a function that returns 0 and 1. 0 means that the item wasn’t present in the transaction, while 1 means the item exists.

```
def encode(val):
if val<=0:
return 0
if val>=1:
return 1
#Let's apply the function to the dataset
Basket=Mar_baskt.applymap(encode)
Basket.head()
```

*#using apriori algorithm to set min_support 0.01 means 1%*
*freq_items = apriori(Basket, min_support = 0.01,use_colnames = True)*
*freq_items.head()*

Using the association_rules() function to generate the most frequent items from the dataset.

App_rule= association_rules(freq_items, metric = "lift", min_threshold = 1) App_rule.sort_values('confidence', ascending = False, inplace = True) App_rule.head()

From the above implementation, the most frequent items are coffee and toast, both having a lift value of 1.47 and a confidence value of 0.70.

Principal component analysis (PCA) is one of the most widely used unsupervised learning techniques. It can be used for various tasks, including dimensionality reduction, information compression, exploratory data analysis and Data de-noising.

Let’s use the PCA algorithm!

First we import the required libraries to implement this algorithm.

```
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
%matplotlib inline
from sklearn.decomposition import PCA
from sklearn.datasets import load_digits
```

To implement the PCA algorithm the load_digits dataset of Scikit-learn is used which can easily be loaded using the below command. The dataset contains images data which include 1797 entries and 64 columns.

```
#Load the dataset
my_data= load_digits()
#Creating features
X_value = my_data.data
#Creating target
#Let's check the shape of X_value
X_value.shape
```

*#Each image is 8x8 pixels therefore 64px *
*my_data.images[10]
*
*#Let's display the image*
*plt.gray() *
*plt.matshow(my_data.images[34]) *
*plt.show()*

Now let’s project data from 64 columns to 16 to show how 16 dimensions classify the data.

```
X_val = my_data.data
y_val = my_data.target
my_pca = PCA(16)
X_projection = my_pca.fit_transform(X_val)
print(X_val.shape)
print(X_projection.shape)
```

Using colormap we visualize that with only ten dimensions we can classify the data points. Now we’ll select the optimal number of dimensions (principal components) by which data can be reduced into lower dimensions.

```
plt.scatter(X_projection[:, 0], X_projection[:, 1], c=y_val, edgecolor='white',
cmap=plt.cm.get_cmap("gist_heat",12))
plt.colorbar();
```

```
pca=PCA().fit(X_val)
plt.plot(np.cumsum(my_pca.explained_variance_ratio_))
plt.xlabel('Principal components')
plt.ylabel('Explained variance')
Based on the below graph, only 12 components are required to explain more than 80% of the variance which is still better than computing all the 64 features. Thus, we’ve reduced the large number of dimensions into 12 dimensions to avoid the dimensionality curse. pca=PCA().fit(X_val)
plt.plot(np.cumsum(pca.explained_variance_ratio_))
plt.xlabel('Principal components')
plt.ylabel('Explained variance')
#Let's visualize how it looks like
Unsupervised_pca = PCA(12)
X_pro = Unsupervised_pca.fit_transform(X_val)
print("New Data Shape is =>",X_pro.shape)
#Let's Create a scatter plot
plt.scatter(X_pro[:, 0], X_pro[:, 1], c=y_val, edgecolor='white',
cmap=plt.cm.get_cmap("nipy_spectral",10))
plt.colorbar();
```

In this machine learning tutorial, we’ve implemented the Kmeans, Apriori, and PCA algorithms. These are some of the most widely used algorithms, having numerous industrial applications and solve many real world problems. For instance, K-means clustering is used in astronomy to study stellar and galaxy spectra, solar polarization spectra, and X-ray spectra. And, Apriori is used by retail stores to optimize their product inventory.

Dreaming of becoming a data scientist or data analyst even without a university and a college degree? Do you need the knowledge of data science and analysis for promotions in your current role?

Are you interested in securing your dream job in data science and analysis and looking for a way to get started, we can help you? With over 10 years of experience in data science and data analysis, we will teach you the rubrics, guiding you with one-on-one lessons from the fundamentals until you become a pro.

Our courses are affordable and easy to understand with numerous exercises and assignments you can learn from. At the completion of our courses, you’ll be readily equipped with technical and practical skills to take on any data science and data analysis role in companies, collaborate effectively among teams and help businesses meet and exceed their objectives by extracting actionable insights from data.

Original article sourced at: https://thedatascientist.com

1618317562

View more: https://www.inexture.com/services/deep-learning-development/

We at Inexture, strategically work on every project we are associated with. We propose a robust set of AI, ML, and DL consulting services. Our virtuoso team of data scientists and developers meticulously work on every project and add a personalized touch to it. Because we keep our clientele aware of everything being done associated with their project so there’s a sense of transparency being maintained. Leverage our services for your next AI project for end-to-end optimum services.

#deep learning development #deep learning framework #deep learning expert #deep learning ai #deep learning services

1593529260

In the previous blog, we looked into the fact why Few Shot Learning is essential and what are the applications of it. In this article, I will be explaining the Relation Network for Few-Shot Classification (especially for image classification) in the simplest way possible. Moreover, I will be analyzing the Relation Network in terms of:

- Effectiveness of different architectures such as Residual and Inception Networks
- Effects of transfer learning via using pre-trained classifier on ImageNet dataset

Moreover, effectiveness will be evaluated on the accuracy, time required for training, and the number of required training parameters.

Please watch the GitHub repository to check out the implementations and keep updated with further experiments.

In few shot classification, our objective is to design a method which can identify any object images by analyzing few sample images of the same class. Let’s the take one example to understand this. Suppose Bob has a client project to design a 5 class classifier, where 5 classes can be anything and these 5 classes can even change with time. As discussed in previous blog, collecting the huge amount of data is very tedious task. Hence, in such cases, Bob will rely upon few shot classification methods where his client can give few set of example images for each classes and after that his system can perform classification young these examples with or without the need of additional training.

In general, in few shot classification four terminologies (N way, K shot, support set, and query set) are used.

**N way:**It means that there will be total N classes which we will be using for training/testing, like 5 classes in above example.**K shot:**Here, K means we have only K example images available for each classes during training/testing.**Support set:**It represents a collection of all available K examples images from each classes. Therefore, in support set we have total N*K images.**Query set:**This set will have all the images for which we want to predict the respective classes.

At this point, someone new to this concept will have doubt regarding the need of support and query set. So, let’s understand it intuitively. Whenever humans sees any object for the first time, we get the rough idea about that object. Now, in future if we see the same object second time then we will compare it with the image stored in memory from the when we see it for the first time. This applied to all of our surroundings things whether we see, read, or hear. Similarly, to recognise new images from query set, we will provide our model a set of examples i.e., support set to compare.

And this is the basic concept behind Relation Network as well. In next sections, I will be giving the rough idea behind Relation Network and I will be performing different experiments on 102-flower dataset.

The Core idea behind Relation Network is to learn the generalized image representations for each classes using support set such that we can compare lower dimensional representation of query images with each of the class representations. And based on this comparison decide the class of each query images. Relation Network has two modules which allows us to perform above two tasks:

**Embedding module:**This module will extract the required underlying representations from each input images irrespective of the their classes.**Relation Module:**This module will score the relation of embedding of query image with each class embedding.

**Training/Testing procedure:**

We can define the whole procedure in just 5 steps.

- Use the support set and get underlying representations of each images using embedding module.
- Take the average of between each class images and get the single underlying representation for each class.
- Then get the embedding for each query images and concatenate them with each class’ embedding.
- Use the relation module to get the scores. And class with highest score will be the label of respective query image.
- [Only during training] Use MSE loss functions to train both (embedding + relation) modules.

Few things to know during the training is that we will use only images from the set of selective class, and during the testing, we will be using images from unseen classes. For example, from the 102-flower dataset, we will use 50% classes for training, and rest will be used for validation and testing. Moreover, in each episode, we will randomly select 5 classes to create the support and query set and follow the above 5 steps.

That is all need to know about the implementation point of view. Although the whole process is simple and easy to understand, I’ll recommend reading the published research paper, Learning to Compare: Relation Network for Few-Shot Learning, for better understanding.

#deep-learning #few-shot-learning #computer-vision #machine-learning #deep learning #deep learning

1603735200

The Deep Learning DevCon 2020, DLDC 2020, has exciting talks and sessions around the latest developments in the field of deep learning, that will not only be interesting for professionals of this field but also for the enthusiasts who are willing to make a career in the field of deep learning. The two-day conference scheduled for 29th and 30th October will host paper presentations, tech talks, workshops that will uncover some interesting developments as well as the latest research and advancement of this area. Further to this, with deep learning gaining massive traction, this conference will highlight some fascinating use cases across the world.

Here are ten interesting talks and sessions of DLDC 2020 that one should definitely attend:

**Also Read:** Why Deep Learning DevCon Comes At The Right Time

**By Dipanjan Sarkar**

**About: **Adversarial Robustness in Deep Learning is a session presented by Dipanjan Sarkar, a Data Science Lead at Applied Materials, as well as a Google Developer Expert in Machine Learning. In this session, he will focus on the adversarial robustness in the field of deep learning, where he talks about its importance, different types of adversarial attacks, and will showcase some ways to train the neural networks with adversarial realisation. Considering abstract deep learning has brought us tremendous achievements in the fields of computer vision and natural language processing, this talk will be really interesting for people working in this area. With this session, the attendees will have a comprehensive understanding of adversarial perturbations in the field of deep learning and ways to deal with them with common recipes.

Read an interview with Dipanjan Sarkar.

**By Divye Singh**

**About: **Imbalance Handling with Combination of Deep Variational Autoencoder and NEATER is a paper presentation by Divye Singh, who has a masters in technology degree in Mathematical Modeling and Simulation and has the interest to research in the field of artificial intelligence, learning-based systems, machine learning, etc. In this paper presentation, he will talk about the common problem of class imbalance in medical diagnosis and anomaly detection, and how the problem can be solved with a deep learning framework. The talk focuses on the paper, where he has proposed a synergistic over-sampling method generating informative synthetic minority class data by filtering the noise from the over-sampled examples. Further, he will also showcase the experimental results on several real-life imbalanced datasets to prove the effectiveness of the proposed method for binary classification problems.

**By Dongsuk Hong**

**About:** This is a paper presentation given by Dongsuk Hong, who is a PhD in Computer Science, and works in the big data centre of Korea Credit Information Services. This talk will introduce the attendees with machine learning and deep learning models for predicting self-employment default rates using credit information. He will talk about the study, where the DNN model is implemented for two purposes — a sub-model for the selection of credit information variables; and works for cascading to the final model that predicts default rates. Hong’s main research area is data analysis of credit information, where she is particularly interested in evaluating the performance of prediction models based on machine learning and deep learning. This talk will be interesting for the deep learning practitioners who are willing to make a career in this field.

#opinions #attend dldc 2020 #deep learning #deep learning sessions #deep learning talks #dldc 2020 #top deep learning sessions at dldc 2020 #top deep learning talks at dldc 2020

1595573880

In this post, we will investigate how easily we can train a Deep Q-Network (DQN) agent (Mnih et al., 2015) for Atari 2600 games using the Google reinforcement learning library Dopamine. While many RL libraries exist, this library is specifically designed with **four essential features** in mind:

- Easy experimentation
- Flexible development
- Compact and reliable
- Reproducible

_We believe these principles makes _

_Dopamine _one of the. Additionally, we even got the library to work on Windows, which we think isbest RL learning environment available today!quite a feat

In my view, the visualization of any trained RL agent is an **absolute must** in reinforcement learning! Therefore, we will (of course) include this for our own trained agent at the very end!

We will go through all the pieces of code required (which is** minimal compared to other libraries**), but you can also find all scripts needed in the following Github repo.

The general premise of deep reinforcement learning is to

“derive efficient representations of the environment from high-dimensional sensory inputs, and use these to generalize past experience to new situations.”

- Mnih et al. (2015)

As stated earlier, we will implement the *DQN model* by *Deepmind*, which only uses raw pixels and game score as input. The raw pixels are processed using convolutional neural networks similar to image classification. The primary difference lies in the **objective function**, which for the DQN agent is called the *optimal action-value function*

where_ rₜ *is the maximum sum of rewards at time t discounted by γ, obtained using a behavior policy* π = P(a_∣_s)_ for each observation-action pair.

There are relatively many details to Deep Q-Learning, such as *Experience Replay* (Lin, 1993) and an _iterative update rule. _Thus, we refer the reader to the original paper for an excellent walk-through of the mathematical details.

One key benefit of DQN compared to previous approaches at the time (2015) was the ability to outperform existing methods for Atari 2600 games using the **same set of hyperparameters** and **only pixel values and game score as input**, clearly a tremendous achievement.

This post does not include instructions for installing Tensorflow, but we do want to stress that you can use **both the CPU and GPU versions**.

Nevertheless, assuming you are using `Python 3.7.x`

, these are the libraries you need to install (which can all be installed via `pip`

):

```
tensorflow-gpu=1.15 (or tensorflow==1.15 for CPU version)
cmake
dopamine-rl
atari-py
matplotlib
pygame
seaborn
pandas
```

#reinforcement-learning #q-learning #games #machine-learning #deep-learning #deep learning