Objectives

• Compute inverse distance functions

• Compute kernel weights functions

• Assess the characteristics of weights based on distance functions

• Understand the contents of KWT format weights files

Getting started

We will again use the data set that contains the location and sales price of 205 homes in a core area of Cleveland, OH for the fourth quarter of 2015. We get started by clearing the previous project and dropping the file clev_sls_154_core.shp into the Drop files here rectangle of the connect to data source dialog. Alternatively, we can use a project file if we saved one earilier (e.g., clev_sls_154_core.gda). The familiar themeless base map results, as in Figure 1.

If desired, we can again add the base layer and change the point colors and selection default. We pass on this for now.

Concepts

One can readily view spatial weights based on a distance cut-off as representing a step function, with a value of 1 for neighbors with \(d_{ij} < \delta\), and a value of 0 for others. As before, \(d_{ij}\) stands for the distance between observations \(i\) and \(j\), and \(\delta\) is the bandwidth.

A straightforward extension of this principle is to consider a continuous parameterized function of distance itself: \[\begin{equation} w_{ij} = f(d_{ij},\mathbf{\theta}), \end{equation}\] with \(f\) as a functional form and \(\mathbf{\theta}\) a vector of parameters.

In order to conform to Tobler’s first law of geography, a distance decay effect must be respected.³ In other words, the value of the function of distance needs to decrease with a growing distance. More formally, the partial derivative of the distance function with respect to distance should be negative, \(\partial w_{ij} / \partial d_{ij} < 0\).

Commonly used distance functions are the inverse, with \(w_{ij} = 1 / d_{ij}^{\alpha}\) (and \(\alpha\) as a parameter), and the negative exponential, with \(w_{ij} = e^{-\beta d_{ij}}\) (and \(\beta\) as a parameter). The functions are often combined with a distance cut-off criterion, such that \(w_{ij} = 0\) for \(d_{ij} > \delta\).

In practice, the parameters are seldom estimated, but typically set to a fixed value, such as \(\alpha = 1\) for inverse distance weights (\(1/d_{ij}\)), and \(\alpha = 2\) for gravity weights (\(1/d_{ij}^{2}\)). By convention, the diagonal elements of the spatial weights are set to zero and not computed. Plugging in a value of \(d_{ii} = 0\) would yield division by zero for inverse distance weights.

The distance-based weights depend not only on the parameter value and functional form, but also on the metric used for distance. Since the weights are inversely related to distance, large values for the latter will yield small values for the former, and vice versa. This may be a problem in practice when the distances are so large (i.e., measured in small units) that the corresponding inverse distance weights become close to zero, possibly resulting in a zero spatial weights matrix.

In addition, a potential problem may occur when the distance metric is such that distances take on values less than one. As a consequence, some inverse distance values may be larger than one, which is typically not a desired result.

Rescaling of the coordinates will fix both problems.

Creating inverse distance functions for distance bands

We proceed in the usual fashion to create spatial weights based on an inverse distance function. In the Weights File Creation interface, we specify unique_id as the ID variable, and select the Distance Weight option.

As before, we choose Distance band from the three types of weights. The default bandwidth of 3598.055030 is the same as encountered previously. We keep it as is for now. The inverse distance option is invoked by the check box below the bandwidth entry, as in Figure 2. For now, we keep the Power value to its default of 1.

Clicking on the Create button results in the usual query for a file name specification. The inverse distance weights are saved in a file with a GWT extension, say clev_sls_154_core_id1.gwt.

Creating inverse distance functions for k-nearest neighbors

Computing inverse distance weights is not limited to a distance band specification. As shown in Figure 8, the inverse distance option is also available for K-Nearest neighbors.

This option works in the same way as for the distance bands. With the Number of neighbors and a Power specified, the new weights are computed from the distances between the k nearest neighbors for each location. In Figure 9, the original k-nearest distances (with k=6, as specified in Figure 8) and the corresponding inverse weights entries are shown from the respective GWT files.

As is the case for the inverse distance band weights, the actual values of the inverse knn weights are ignored in further spatial analyses in GeoDa. They can only be used in the calculation of spatially explicit variables.⁶

Concepts

Kernel weights are used in non-parametric approaches to model spatial covariance, such as in the HAC method for heteroskedastic and spatial autocorrelation consistent variance estimates.⁷ In GeoDa, kernel functions can be computed, but as is the case for the other distance functions, the actual values of the weights are only used in the computation of spatially explicit variables.

The kernel weights are defined as a function \(K(z)\) of the ratio between the distance \(d_{ij}\) from \(i\) to \(j\), and the bandwidth \(h_i\), with \(z = d_{ij} / h_i\). This ensures that \(z\) is always less than 1. For distances greater than the bandwidth, \(K(z) = 0\).

Five different kernel weights functions are currently supported:

• Uniform, \(K(z) = 1/2\) for \(|z| < 1\),
• Triangular, \(K(z) = (1 - |z| )\) for \(|z| < 1\),
• Quadratic or Epanechnikov, \(K(z) = (3/4) (1 - z^2)\) for \(|z| < 1\),⁸
• Quartic, \(K(z) = (15/16)(1 - z^2)^2\) for \(|z| < 1\), and
• Gaussian. \(K(z) = (2 \pi)^{(1/2)} \exp(- z^2 / 2)\).⁹

Typically, the value for the diagonal elements of the weights is set to 1, although GeoDa allows for the actual kernel value to be used as well.

Many careful decisions must be made in selecting a kernel weights function. Apart from the choice of a functional form for \(K(\ )\), a crucial aspect is the selection of the bandwidth. In the literature, the latter is found to be more important than the functional form.

A drawback of fixed bandwidth kernel weights is that the number of non-zero weights can vary considerably, especially when the density of the point locations is not uniform throughout space. This is the same problem encountered for the distance band spatial weights.

In GeoDa, there are two types of fixed bandwidths for kernel weights. One is the max-min distance used earlier (the largest of the nearest-neighbor distances). The other is the maximum distance for a given specification of k-nearest neighbors. For example, with knn set to a given value, this is the distance between the selected k-nearest neighbors pairs that are the farthest apart.

To correct for the issues associated with a fixed bandwidth, a variable bandwidth approach adjusts the bandwidth for each location to ensure equal or near-equal coverage. One common approach is to take the k-nearest neighbors, and to adjust the bandwidth for each location such that exactly k neighbors are included in the kernel function. The bandwidth specific to each location is then any distance larger than its k nearest neighbor distance, but less than the k+1 nearest neighbor distance.

In GeoDa, the default value for k equals the cube root of the number of observations (following the recommendation in Kelejian and Prucha 2007). In general, a wider bandwidth gives smoother and more robust results, so the bandwidth should always be set at least as large as the recommended default.

Creating kernel weights

We create kernel weights in the by now familiar fashion, by selecting the Adaptive kernel option under the Distance Weight button of the Weights File Creation dialog. Figure 10 illustrates the five kernel functions that are available.

To illustrate this functionality, we select the Triangular option, with the Adaptive bandwidth set to the default number of neighbors of 6. We also leave the Diagonal weights option to its default of 1 (i.e., the kernel function is not applied to a distance of zero for the diagonal elements). These settings are illustrated in Figure 11.

The results are saved in a file with file extension KWT (such as clev_sls_154_core_tri6.kwt). The KWT file extension is adopted to retain compatibility with the conventions assumed for PySAL and its spreg module, as implemented in GeoDaSpace. Except for the inclusion of the diagonal element, its structure is the same as a GWT format file.

The contents of the KWT file in our example are shown in the right-hand panel of Figure 12, compared to the knn distances in the corresponding GWT file on the left.

A few characteristics of the results should be noted. First, the bandwidth is determined by the largest distance among the six neighbors. In the current example, for the first observation considered (with unique_id 1183), this is the distance given on the first row. The distance between 1183 and 6842 amounts to 3253.02459, as shown in the left panel of Figure 12. By convention, each other distance is converted to a value less than one by dividing it by this maximum distance.

For example, for the second pair (between 1183 and 2024), this would yield 1858.90398/3253.02459 = 0.571439 (the \(z\)-value referred to above). The result for the triangular kernel is then 1 - 0.571439 = 0.428561, i.e., the value shown on the second line of the KWT file.

For the pair with the largest distance, the value of the kernel is zero (1 - 1). Finally, for the diagonal element (the pair 1183, 1183), the kernel is given as 1, by construction.¹⁰