Julia core density estimate

Question

I am trying to implement a kernel density estimate. However, my code does not give an answer. It is also written in julia, but the code should be clear.

Here is the algorithm:

Where

Thus, the algorithm checks whether the distance between x and the observation X_i is smaller by using a certain constant factor (bin width). If so, he assigns this value 0.5 / (n * h), where n = # observations.

Here is my implementation:

#Kernel density function.
#Purpose: estimate the probability density function (pdf)
#of given observations
#@param data: observations for which the pdf should be estimated
#@return: returns an array with the estimated densities 

function kernelDensity(data)
|   
|   #Uniform kernel function. 
|   #@param x: Current x value
|   #@param X_i: x value of observation i
|   #@param width: binwidth
|   #@return: Returns 1 if the absolute distance from
|   #x(current) to x(observation) weighted by the binwidth
|   #is less then 1. Else it returns 0.
|  
|   function uniformKernel(x, observation, width)
|   |   u = ( x - observation ) / width
|   |   abs ( u ) <= 1 ? 1 : 0
|   end
|
|   #number of observations in the data set 
|   n = length(data)
|
|   #binwidth (set arbitraily to 0.1
|   h = 0.1 
|   
|   #vector that stored the pdf
|   res = zeros( Real, n )
|   
|   #counter variable for the loop 
|   counter = 0
|
|   #lower and upper limit of the x axis
|   start = floor(minimum(data))
|   stop = ceil (maximum(data))
|
|   #main loop
|   #@linspace: divides the space from start to stop in n
|   #equally spaced intervalls
|   for x in linspace(start, stop, n) 
|   |   counter += 1
|   |   for observation in data
|   |   |
|   |   |   #count all observations for which the kernel
|   |   |   #returns 1 and mult by 0.5 because the
|   |   |   #kernel computed the absolute difference which can be
|   |   |   #either positive or negative
|   |   |   res[counter] += 0.5 * uniformKernel(x, observation, h)
|   |   end
|   |   #devide by n times h
|   |   res[counter] /= n * h
|   end
|   #return results
|   res
end
#run function
#@rand: generates 10 uniform random numbers between 0 and 1
kernelDensity(rand(10))

and this returns:

> 0.0
> 1.5
> 2.5
> 1.0
> 1.5
> 1.0
> 0.0
> 0.5
> 0.5
> 0.0

the sum of which is equal to: 8.5 (cumulative distribution function should be 1.)

So there are two errors:

• Values ​​do not scale properly. Each number should be about one tenth of their current values. In fact, if the number of observations increases by 10 ^ nn = 1, 2, ... then cdf also increases by 10 ^ n

For example:

> kernelDensity(rand(1000))
> 953.53 

2. 10 ( , ). : . 5% .

, 1:1, , .

Answer 1

KDE, , ( !) :

function kernelDensity{T<:AbstractFloat}(data::Vector{T}, h::T)
  res = similar(data)
  lb = minimum(data); ub = maximum(data)
  for (i,x) in enumerate(linspace(lb, ub, size(data,1)))
    for obs in data
      res[i] += abs((obs-x)/h) <= 1. ? 0.5 : 0.
    end
    res[i] /= (n*h)
 end
 sum(res)
end

, 1, , kernelDensity(rand(100), 0.1)/100 , , 1. , 5% , 0,1 ( h=0.135, 0,1%), ​​ 93% "".

Julia , , , , Pkg.add("KernelDensity") , :)

Answer 2

: n B_i 2h, [0,1], X < img src= "https://i.stack.imgur.com/LpP2I.gif" alt= "E\sum_ {i = 1} ^ {n} 1 {X\in B_i} = n E 1 {X\in B_i} = 2 nh" > bins, 2 n h.

n .

, < 2. (, start = 0, [0,1]), , .

Edit: Btw, , , [0,1]. h/2 = 5% .