Machine Learning Archives - Page 2 of 5

Human detection and Pose Estimation with Deep Learning for Sport Analysis

1 Comment / C++, Computer Vision, Image Processing, Machine Learning, Tutorials / admin

Pose estimation and tracking human is one the key step in sports analysis. Here is in this work I used openpose for analysis of player in a Bundesliga game HSV Hamburg vs Bayer München. Warning: the video might be disturbing for HSV fans 🙂 Original Video Analyzed Video Original Video Analyzed Video Original Video Analyzed Video Original Video […]

Human detection and Pose Estimation with Deep Learning for Sport Analysis Read More »

Breadth-first search (BFS) and Depth-first search (DSF) Algorithm with Python and C++

Leave a Comment / C++, Machine Learning, Python, Tutorials / admin

Python Implementation BFS traverse:

Root='a'
g.nodes[Root]['visited']=True
print Root 
Q=[Root]
BFS_travrse(Q,g)

Root='a'

g.nodes[Root]['visited']=True

print Root

Q=[Root]

BFS_travrse(Q,g)

DFS traverse:

Root='a'
print Root
g.nodes[Root]['visited']=True
coloring_tree(g)
DFS_travrse(Root,g)

Root='a'

print Root

g.nodes[Root]['visited']=True

coloring_tree(g)

DFS_travrse(Root,g)

import networkx as nx
import matplotlib.pyplot as plt
from networkx.drawing.nx_agraph import write_dot, graphviz_layout


def coloring_tree(G):

    visited_list=[]
    for i in G.nodes():
        visited_list.append( g.nodes[i]['visited'] )
    
    graph_color_map=[]
    for i  in visited_list:
        if i:
            color='blue'
        else:
            color='red'
        graph_color_map.append(color)
    pos =graphviz_layout(G, prog='dot')
    nx.draw(G, pos, with_labels=True, arrows=True,node_color =  graph_color_map)
    #plt.savefig('nx_test.png')
    plt.show()
    
    return

def DFS_travrse(N,G):
    neighbors =G.neighbors(N)
    size=len( list(neighbors))
    if size==0:
        return
    neighbors =G.neighbors(N)
    for neighbor in neighbors:
        G.nodes[neighbor]['visited']=True
        coloring_tree(G)
        DFS_travrse(neighbor,G)
    return

def BFS_travrse(Q,G):
    if len(Q)==0:
        return
    Root=Q[0]
    Q=Q[1:len(Q)]
    neighbors =G.neighbors(Root)
    for neighbor in neighbors:
        print neighbor
        coloring_tree(G)
        G.nodes[neighbor]['visited']=True
        Q.append(neighbor)
 
    BFS_travrse(Q,G)
    return


g=nx.DiGraph()
g.add_node('a',visited=False)
g.add_node('b',visited=False)
g.add_node('c',visited=False)
g.add_node('d',visited=False)
g.add_node('e',visited=False)
g.add_node('f',visited=False)
g.add_node('g',visited=False)
g.add_node('h',visited=False)


g.add_edge('a','b')
g.add_edge('a','c')
g.add_edge('b','e')
g.add_edge('b','d')
g.add_edge('e','h')
g.add_edge('c','f')
g.add_edge('c','g')

import networkx as nx

import matplotlib.pyplot as plt

from networkx.drawing.nx_agraph import write_dot, graphviz_layout

def coloring_tree(G):

visited_list=[]

for i in G.nodes():

visited_list.append( g.nodes[i]['visited'] )

graph_color_map=[]

for i in visited_list:

if i:

color='blue'

else:

color='red'

graph_color_map.append(color)

pos =graphviz_layout(G, prog='dot')

nx.draw(G, pos, with_labels=True, arrows=True,node_color = graph_color_map)

#plt.savefig('nx_test.png')

plt.show()

return

def DFS_travrse(N,G):

neighbors =G.neighbors(N)

size=len( list(neighbors))

if size==0:

return

neighbors =G.neighbors(N)

for neighbor in neighbors:

G.nodes[neighbor]['visited']=True

coloring_tree(G)

DFS_travrse(neighbor,G)

return

def BFS_travrse(Q,G):

if len(Q)==0:

return

Root=Q[0]

Q=Q[1:len(Q)]

neighbors =G.neighbors(Root)

for neighbor in neighbors:

print neighbor

coloring_tree(G)

G.nodes[neighbor]['visited']=True

Q.append(neighbor)

BFS_travrse(Q,G)

return

g=nx.DiGraph()

g.add_node('a',visited=False)

g.add_node('b',visited=False)

g.add_node('c',visited=False)

g.add_node('d',visited=False)

g.add_node('e',visited=False)

g.add_node('f',visited=False)

g.add_node('g',visited=False)

g.add_node('h',visited=False)

g.add_edge('a','b')

g.add_edge('a','c')

g.add_edge('b','e')

g.add_edge('b','d')

g.add_edge('e','h')

g.add_edge('c','f')

g.add_edge('c','g')

C++ Implementation

#include <algorithm>
#include <iostream>
#include <memory>

class node
{
public:
    std::vector<std::shared_ptr<node> > leaves;
    double data;
};

void populateTree(std::shared_ptr<node> rootNodePtr)
{
/*
                   -1
                  /   \
                3       7
              /  \    /
             4    1  5
*/

    rootNodePtr->data=-1;
    std::shared_ptr<node>  leftNodePtr,rightNodePtr;
    std::shared_ptr<node>  leftNode1stKidPtr,leftNode2ndtKidPtr, rightNode1stKidPtr;

    leftNodePtr.reset(new node) ;
    rightNodePtr.reset(new node);
    rootNodePtr->leaves.push_back(leftNodePtr);
    rootNodePtr->leaves.push_back(rightNodePtr);

    leftNodePtr->data=3;
    rightNodePtr->data=7;

    leftNode1stKidPtr.reset(new node);
    leftNode2ndtKidPtr.reset(new node);
    rightNode1stKidPtr.reset(new node);

    leftNode1stKidPtr->data=4;
    leftNode2ndtKidPtr->data=1;
    rightNode1stKidPtr->data=5;

    leftNodePtr->leaves.push_back(leftNode1stKidPtr);
    leftNodePtr->leaves.push_back(leftNode2ndtKidPtr);

    rightNodePtr->leaves.push_back(rightNode1stKidPtr);

}

void DFS(std::shared_ptr<node> rootNode)
{
    std::cout<<rootNode->data <<std::endl;
    for(auto n:rootNode->leaves)
        DFS(n);
}

void BFS(std::shared_ptr<node> rootNode)
{

    for(auto n:rootNode->leaves)
        std::cout<<n->data <<std::endl;

    for(auto n:rootNode->leaves)
        BFS(n);
}
int main()
{
    std::shared_ptr<node> tree(new node);
    populateTree(tree);
    DFS(tree);
    BFS(tree); 
}

#include <algorithm>

#include <iostream>

#include <memory>

class node

{

public:

std::vector<std::shared_ptr<node> > leaves;

double data;

};

void populateTree(std::shared_ptr<node> rootNodePtr)

{

-1

/ \

3 7

/ \ /

4 1 5

rootNodePtr->data=-1;

std::shared_ptr<node> leftNodePtr,rightNodePtr;

std::shared_ptr<node> leftNode1stKidPtr,leftNode2ndtKidPtr, rightNode1stKidPtr;

leftNodePtr.reset(new node) ;

rightNodePtr.reset(new node);

rootNodePtr->leaves.push_back(leftNodePtr);

rootNodePtr->leaves.push_back(rightNodePtr);

leftNodePtr->data=3;

rightNodePtr->data=7;

leftNode1stKidPtr.reset(new node);

leftNode2ndtKidPtr.reset(new node);

rightNode1stKidPtr.reset(new node);

leftNode1stKidPtr->data=4;

leftNode2ndtKidPtr->data=1;

rightNode1stKidPtr->data=5;

leftNodePtr->leaves.push_back(leftNode1stKidPtr);

leftNodePtr->leaves.push_back(leftNode2ndtKidPtr);

rightNodePtr->leaves.push_back(rightNode1stKidPtr);

}

void DFS(std::shared_ptr<node> rootNode)

{

std::cout<<rootNode->data <<std::endl;

for(auto n:rootNode->leaves)

DFS(n);

}

void BFS(std::shared_ptr<node> rootNode)

{

for(auto n:rootNode->leaves)

std::cout<<n->data <<std::endl;

for(auto n:rootNode->leaves)

BFS(n);

}

int main()

{

std::shared_ptr<node> tree(new node);

populateTree(tree);

DFS(tree);

BFS(tree);

}

Breadth-first search (BFS) and Depth-first search (DSF) Algorithm with Python and C++ Read More »

RANSAC Algorithm parameter explained

2 Comments / Machine Learning, Matlab, Tutorials / admin

In this tutorial I explain the RANSAC algorithm, their corresponding parameters and how to choose the number of samples: N = number of samples e = probability that a point is an outlier s = number of points in a sample p = desired probability that we get a good sample N =log(1-p) /log(1- (1-

RANSAC Algorithm parameter explained Read More »

Examples of Dynamic Programming with C++ and Matlab

Leave a Comment / C++, Machine Learning, Matlab, Tutorials / admin

In this tutorial, I will give you examples of using dynamic programming for solving the following problems: 1)Minimum number of coins for summing X.

int c[]={1,3,4}; // value of coins
int k=3; //number of cpins that we have

/*
The d[20] array is for memorization, for instance if we computed f_coin_problem_memo(3),
we put this value in d[3] and we don't compute it again, we just use d[3] instead of f_coin_problem_memo(3)
*/
int d[20];
int f_coin_problem_memo(int x)
{
    if (x < 0) return 1e9;
    if (x == 0) return 0;
    if (d[x]) return d[x];
    int u = 1e9;
    int u_old = 1e9;
    for (int i = 0; i < k; i++)
    {
        u_old=u;
        u = std::min(u, f_coin_problem_memo(x-c[i]) +1);
    }
    d[x] = u;
    return d[x];
}

int c[]={1,3,4}; // value of coins

int k=3; //number of cpins that we have

The d[20] array is for memorization, for instance if we computed f_coin_problem_memo(3),

we put this value in d[3] and we don't compute it again, we just use d[3] instead of f_coin_problem_memo(3)

int d[20];

int f_coin_problem_memo(int x)

{

if (x < 0) return 1e9;

if (x == 0) return 0;

if (d[x]) return d[x];

int u = 1e9;

int u_old = 1e9;

for (int i = 0; i < k; i++)

{

u_old=u;

u = std::min(u, f_coin_problem_memo(x-c[i]) +1);

}

d[x] = u;

return d[x];

}

The minimum number of coins from the set {1,3,4} to sum up value of 12 is:
3

1 2	The minimum number of coins from the set {1,3,4} to sum up value of 12 is: 3

2)The most (least) costly path on a grid (dynamic time warping).

finding a path in an n × n grid from the upper-left corner to the lower-right corner. We are only allowed
 to move right or down.

1,1  1,2 .... 1,X
2,1  2,2 .... 2,X
.
.
.
Y,1  Y,2 .... Y,X


3 7 9 2 7
9 8 3 5 5
1 7 9 8 5
3 8 6 4 10
6 3 9 7 8

*/

int grid[5][5]={{3,7, 9, 2, 7},{9, 8, 3 ,5 ,5},{1, 7 ,9 ,8 ,5},{3, 8, 6 ,4 ,10},{6, 3 ,9 ,7 ,8}};
int memo[5][5]{{-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1}};

std::vector<int>x_solution,y_solution;

int f_paths_in_grid(int y,int x)
{
    if((x==0)&& (y==0))
    {
        memo[y][x]=grid[0][0];
    }
    else if (x==0)
    {
        if(memo[y][x]<0)
        {
            memo[y][x] =f_paths_in_grid(y-1,x) +grid[y][x];
        }
    }
    else if(y==0)
    {
       if(memo[y][x]<0)
       {
            memo[y][x]=f_paths_in_grid(y,x-1) +grid[y][x];
       }
    }
   else if(memo[y][x]<0)
   {
        memo[y][x]=std::max(f_paths_in_grid(y,x-1)  ,f_paths_in_grid(y-1,x)  )+grid[y][x];
    }
    return  memo[y][x];
}

finding a path in an n × n grid from the upper-left corner to the lower-right corner. We are only allowed

to move right or down.

1,1 1,2 .... 1,X

2,1 2,2 .... 2,X

Y,1 Y,2 .... Y,X

3 7 9 2 7

9 8 3 5 5

1 7 9 8 5

3 8 6 4 10

6 3 9 7 8

int grid[5][5]={{3,7, 9, 2, 7},{9, 8, 3 ,5 ,5},{1, 7 ,9 ,8 ,5},{3, 8, 6 ,4 ,10},{6, 3 ,9 ,7 ,8}};

int memo[5][5]{{-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1},{-1,-1,-1,-1,-1}};

std::vector<int>x_solution,y_solution;

int f_paths_in_grid(int y,int x)

{

if((x==0)&& (y==0))

{

memo[y][x]=grid[0][0];

}

else if (x==0)

{

if(memo[y][x]<0)

{

memo[y][x] =f_paths_in_grid(y-1,x) +grid[y][x];

}

else if(y==0)

{

if(memo[y][x]<0)

{

memo[y][x]=f_paths_in_grid(y,x-1) +grid[y][x];

}

else if(memo[y][x]<0)

{

memo[y][x]=std::max(f_paths_in_grid(y,x-1) ,f_paths_in_grid(y-1,x) )+grid[y][x];

}

return memo[y][x];

}

maximum sum on a path from the upper-left corner to the lower-right corner is:
67
3|10|19|21|28|
---------------
12|20|23|28|33|
---------------
13|27|36|44|49|
---------------
16|35|42|48|59|
---------------
22|38|51|58|67|
---------------

maximum sum on a path from the upper-left corner to the lower-right corner is:

3|10|19|21|28|

---------------

12|20|23|28|33|

---------------

13|27|36|44|49|

---------------

16|35|42|48|59|

---------------

22|38|51|58|67|

---------------

3)Levenshtein edit distance.

int LevenshteinDistance(std::string s, std::string t )
{
  int cost;

  /* base case: empty strings */
  if (s.length() == 0) return t.length();
  if (t.length() == 0) return s.length();

  /* test if last characters of the strings match */
  if (s.at(s.length()-1)  == t.at(t.length()-1) )
      cost = 0;
  else
      cost = 1;

  /* return minimum of delete char from s, delete char from t, and delete char from both */

  return std::min(   std::min(LevenshteinDistance(s.substr(0, s.size()-1 ),t ) + 1,LevenshteinDistance(s  , t.substr(0, t.size()-1 )) + 1 )    ,  LevenshteinDistance(s.substr(0, s.size()-1 ), t.substr(0, t.size()-1 )) + cost );
}

int LevenshteinDistance(std::string s, std::string t )

{

int cost;

/* base case: empty strings */

if (s.length() == 0) return t.length();

if (t.length() == 0) return s.length();

/* test if last characters of the strings match */

if (s.at(s.length()-1) == t.at(t.length()-1) )

cost = 0;

else

cost = 1;

/* return minimum of delete char from s, delete char from t, and delete char from both */

return std::min( std::min(LevenshteinDistance(s.substr(0, s.size()-1 ),t ) + 1,LevenshteinDistance(s , t.substr(0, t.size()-1 )) + 1 ) , LevenshteinDistance(s.substr(0, s.size()-1 ), t.substr(0, t.size()-1 )) + cost );

}

The Levenshtein distance between saturday and sunday is:
3

1 2	The Levenshtein distance between saturday and sunday is: 3

4)Seam Carving. I have written a tutorial on that

Examples of Dynamic Programming with C++ and Matlab Read More »

Seam Carving Algorithm for Content-Aware Image Resizing with Matlab Code

1 Comment / Computer Vision, Image Processing, Machine Learning, Tutorials / admin

Seam carving is an algorithm for resizing images while keeping the most prominent and conspicuous pixels in the image. The important pixels in an image are usually those who are located over horizontal or vertical edges, so to throw away some pixels we first find horizontal and vertical edges and store their magnitude as pixel

Seam Carving Algorithm for Content-Aware Image Resizing with Matlab Code Read More »

Hierarchical Clustring in python

Leave a Comment / Machine Learning, Python, Tutorials / admin

Hierarchical Clustering is a method of clustering which build a hierarchy of clusters. It could be Agglomerative or Divisive. Agglomerative: At the first step, every item is a cluster, then clusters based on their distances are merged and form bigger clusters till all data is in one cluster (Bottom Up). The complexity is \( O (n^2log(n) ) \). Divisive: At the beginning,

Hierarchical Clustring in python Read More »

Maximum likelihood estimation explained

Leave a Comment / Machine Learning, Tutorials / admin

In this tutorial, I explain the “Maximum likelihood” and MLE (maximum likelihood estimation) for binomial and Gaussian distribution.

Maximum likelihood estimation explained Read More »

Naive Bayes Classifier Explained

Leave a Comment / Machine Learning, Python, Tutorials / admin

In this video, I explain the “Naive Bayes Classifier”. The example has been solved with phyton in my other post here

Naive Bayes Classifier Explained Read More »

HARRIS Corner detector explained

4 Comments / Computer Vision, Image Processing, Linear Algebra, Machine Learning, Tutorials / admin

im = imread('chessboard.jpg');
im = double(rgb2gray(im))/255;

sigma = 5;
g = fspecial('gaussian', 2*sigma*3+1, sigma);
dx = [-1 0 1;-1 0 1; -1 0 1];
Ix = imfilter(im, dx, 'symmetric', 'same');
Iy = imfilter(im, dx', 'symmetric', 'same');
Ix2 = imfilter(Ix.^2, g, 'symmetric', 'same');
Iy2 = imfilter(Iy.^2, g, 'symmetric', 'same');
Ixy = imfilter(Ix.*Iy, g, 'symmetric', 'same');
k = 0.04; % k is between 0.04 and 0.06
% --- r = Det(M) - kTrace(M)^2 ---
r = (Ix2.*Iy2 - Ixy.^2) - k*(Ix2 + Iy2).^2;

norm_r = r - min(r(:));
norm_r = norm_r ./ max(norm_r(:));
subplot(1,2,1), imshow(im)
subplot(1,2,2), imshow(norm_r)


%hLocalMax = vision.LocalMaximaFinder;
%hLocalMax.MaximumNumLocalMaxima = 100;
%hLocalMax.NeighborhoodSize = [3 3];
%hLocalMax.Threshold = 0.05;
%location = step(hLocalMax, norm_r);

im = imread('chessboard.jpg');

im = double(rgb2gray(im))/255;

sigma = 5;

g = fspecial('gaussian', 2*sigma*3+1, sigma);

dx = [-1 0 1;-1 0 1; -1 0 1];

Ix = imfilter(im, dx, 'symmetric', 'same');

Iy = imfilter(im, dx', 'symmetric', 'same');

Ix2 = imfilter(Ix.^2, g, 'symmetric', 'same');

Iy2 = imfilter(Iy.^2, g, 'symmetric', 'same');

Ixy = imfilter(Ix.*Iy, g, 'symmetric', 'same');

k = 0.04; % k is between 0.04 and 0.06

% --- r = Det(M) - kTrace(M)^2 ---

r = (Ix2.*Iy2 - Ixy.^2) - k*(Ix2 + Iy2).^2;

norm_r = r - min(r(:));

norm_r = norm_r ./ max(norm_r(:));

subplot(1,2,1), imshow(im)

subplot(1,2,2), imshow(norm_r)

%hLocalMax = vision.LocalMaximaFinder;

%hLocalMax.MaximumNumLocalMaxima = 100;

%hLocalMax.NeighborhoodSize = [3 3];

%hLocalMax.Threshold = 0.05;

%location = step(hLocalMax, norm_r);

HARRIS Corner detector explained Read More »

Naive Bayes Classifier Example with Python Code

Leave a Comment / Machine Learning, Python, Tutorials / admin

In the below example I implemented a “Naive Bayes classifier” in python and in the following I used “sklearn” package to solve it again: and the output is:

male posterior is:
1.54428667821e-07
female posterior is:
0.999999845571
Then our data must belong to the female class
Then our data must belong to the class number:
[2]

male posterior is:

1.54428667821e-07

female posterior is:

0.999999845571

Then our data must belong to the female class

Then our data must belong to the class number:

[2]

Naive Bayes Classifier Example with Python Code Read More »

Cookie	Duration	Description
cookielawinfo-checbox-analytics	11 months	This cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Analytics".
cookielawinfo-checbox-functional	11 months	The cookie is set by GDPR cookie consent to record the user consent for the cookies in the category "Functional".
cookielawinfo-checbox-others	11 months	This cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Other.
cookielawinfo-checkbox-necessary	11 months	This cookie is set by GDPR Cookie Consent plugin. The cookies is used to store the user consent for the cookies in the category "Necessary".
cookielawinfo-checkbox-performance	11 months	This cookie is set by GDPR Cookie Consent plugin. The cookie is used to store the user consent for the cookies in the category "Performance".
viewed_cookie_policy	11 months	The cookie is set by the GDPR Cookie Consent plugin and is used to store whether or not user has consented to the use of cookies. It does not store any personal data.