The default case in Geoda is to use row-standardized weights and to leave out the diagonal element. Implementing this will be relatively simple, as we will only need one line of code with the weights structure: k6.weights1. To create the lag variable, the spdep function, lag.listw is used. The inputs require a weights structure and a variable with the same length as the weights structure. The length should not be a problem if the variable comes from the same dataset used to create your weights.
+
Spatial lag with row-standardized weights
+
The default case in Geoda is to use row-standardized weights and to leave out the diagonal element. Implementing this
+will be relatively simple, as we will only need one line of code with the weights structure:
+k6.weights1. To create the lag variable, the spdep function, lag.listw is used. The inputs require
+a weights structure and a variable with the same length as the weights structure. The length should not
+be a problem if the variable comes from the same dataset used to create your weights.
+
We create a new data frame of the sale_price variable and the lag variable to get a side by side
+look. To get a brief look at the first few observations of both variables, we use head. Then to get
+a nicer looking table, we use kable from the knitr package.
+
lag1 <- lag.listw(k6.weights1, clev.points$sale_price)
+df <- data.frame(sale_price = clev.points$sale_price, lag1)
+kable(head(df))
-
The values match with the example from the Geoda workbook, only difference being in that it is rounded to less significant figures than GeoDa.
-
The lag variables are calculated in this instance, by taking an average of the neighboring values. We will illustrate this by finding the neighboring sale price values for the first observation. To get these values, we get the neighbor ids for the first observation by double bracket notation. We then select the sale price values by indexing with the resulting numeric vector.
-
nb1 <- k6[[1]]
-nb1 <- clev.points$sale_price[nb1]
-nb1
+
The values match with the example from the Geoda workbook, only difference being in that it is rounded to less
+significant figures than GeoDa.
+
The lag variables are calculated in this instance, by taking an average of the neighboring values. We will
+illustrate this by finding the neighboring sale price values for the first observation. To get these values,
+we get the neighbor ids for the first observation by double bracket notation. We then select the sale
+price values by indexing with the resulting numeric vector.
+
nb1 <- k6[[1]]
+nb1 <- clev.points$sale_price[nb1]
+nb1
## [1] 65000 120000 131650 81500 76000 5000
-
We now verify the value for the spatial lag listed in the table. It is obtained as the average of the sales price for the six neighbors, or (131650 + 65000 + 81500 + 76000 + 120000 + 5000)/6 = 79858.33.
-
We can quickly assess the effect of spatial averaging by comparing the descriptive statistics for the lag variable with those of the original sale price variable.
-
summary(clev.points$sale_price)
+
We now verify the value for the spatial lag listed in the table. It is obtained as the average of the sales price
+for the six neighbors, or (131650 + 65000 + 81500 + 76000 + 120000 + 5000)/6 = 79858.33.
+
We can quickly assess the effect of spatial averaging by comparing the descriptive statistics for the lag variable
+with those of the original sale price variable.
+
summary(clev.points$sale_price)
## Min. 1st Qu. Median Mean 3rd Qu. Max.
## 1049 9000 20000 41897 48500 527409
-
+
## Min. 1st Qu. Median Mean 3rd Qu. Max.
## 6583 16142 26500 39818 54417 229583
-
As seen above, the range for the original sale price variable is 1,049 to 527,409. The range for the lag variable is much more compressed, being 6,583 to 229,583. The typical effect of spatial lag is a compression of the range and variance of a variable. We can see this further when examing the standard deviation.
-
sd(clev.points$sale_price)
+
As seen above, the range for the original sale price variable is 1,049 to 527,409. The range for the
+lag variable is much more compressed, being 6,583 to 229,583. The typical effect of spatial lag is a compression
+of the range and variance of a variable. We can see this further when examing the standard deviation.
+
sd(clev.points$sale_price)
## [1] 60654.34
-
+
## [1] 36463.76
-
The standard deviation for home sales gets significantly condensed from 60654.34 to 36463.76 in the creation of the lag variable.
+
The standard deviation for home sales gets significantly condensed from 60654.34 to 36463.76 in the creation
+of the lag variable.
-
PCP
-
To get a more dramatic view of the influence of high-valued or low-valued neighbors on the spatial lag, we use a parallel coordinates plot. This will be done using GGally, which is an R package that builds off of the ggplot2 package for some more complicated plots, ie the parallel coordinates plot and the scatter plot matrix. We won't go in depth about the different options this package offers in this notebook, but if interested, check out GGally documentation.
-
To make the pcp with just the two variables, we will need to put them in a separate matrix, or data frame. We use cbind to do this, as with the coordinates. From there we use ggparcoord from the GGally package. The necessary inputs are the data(pcp.vars) and the scale parameter. We use `scale = "globalminmax" to keep the same price values as our lag variable and sale price variable. The default option scales it down, which is not what we are looking for in this case.
-
sale.price <- clev.points$sale_price
-pcp.vars <- cbind(sale.price,lag1)
-ggparcoord(data = pcp.vars,scale ="globalminmax") +
- ggtitle("Parallel Coordinate Plot")
+
+
PCP
+
To get a more dramatic view of the influence of high-valued or low-valued neighbors on the spatial lag, we use
+a parallel coordinates plot. This will be done using GGally, which is an R package that builds off of the
+ggplot2 package for some more complicated plots, ie the parallel coordinates plot and the scatter plot
+matrix. We won’t go in depth about the different options this package offers in this notebook, but if interested,
+check out GGally documentation.
+
To make the pcp with just the two variables, we will need to put them in a separate matrix, or data
+frame. We use cbind to do this, as with the coordinates. From there we use ggparcoord from the GGally
+package. The necessary inputs are the data(pcp.vars) and the scale parameter. We use `scale = “globalminmax”
+to keep the same price values as our lag variable and sale price variable. The default option scales it down,
+which is not what we are looking for in this case.
+
sale.price <- clev.points$sale_price
+pcp.vars <- cbind(sale.price,lag1)
+ggparcoord(data = pcp.vars,scale ="globalminmax") +
+ ggtitle("Parallel Coordinate Plot")
-
-
Spatial lag as a sum of neighboring values
-
We can calculate spatial lag as a sum of neighboring values by assigning binary weights. This requires us to go back to our neighbors list, then apply a function that will assign binary weights, then we use glist = in the nb2listw function to explicitly assign these weights.
-
We start by applying a function that will assign a value of 1 per each neighbor. This is done with lapply, which we have been using to manipulate the neighbors structure throughout the past notebooks. Basically it applies a function across each value in the neighbors structure.
-
binary.weights <- lapply(k6, function(x) 0*x + 1)
-k6.weights2 <- nb2listw(k6, glist = binary.weights, style = "B")
-
With the proper weights assigned, we can use lag.listw to compute a lag variable from our weight and sale price data.
-
lag2 <- lag.listw(k6.weights2, clev.points$sale_price)
-df <- df %>% mutate(lag2 = lag2)
-kable(head(df))
+
+
Spatial lag as a sum of neighboring values
+
We can calculate spatial lag as a sum of neighboring values by assigning
+binary weights. This requires us to go back to our neighbors list, then
+apply a function that will assign binary weights, then we use glist = in
+the nb2listw function to explicitly assign these weights.
+
We start by applying a function that will assign a value of 1 per each neighbor. This is done with lapply, which we have been using to manipulate
+the neighbors structure throughout the past notebooks. Basically it applies
+a function across each value in the neighbors structure.
+
binary.weights <- lapply(k6, function(x) 0*x + 1)
+k6.weights2 <- nb2listw(k6, glist = binary.weights, style = "B")
+
With the proper weights assigned, we can use lag.listw to compute a lag
+variable from our weight and sale price data.
+
lag2 <- lag.listw(k6.weights2, clev.points$sale_price)
+df <- df %>% mutate(lag2 = lag2)
+kable(head(df))
-
-
Spatial window average
-
The spatial window average uses row-standardized weights and includes the diagonal element. To do this in R, we need to go back to the neighbors structure and add the diagonal element before assigning weights. To begin we assign k6 to a new variable because we will directly alter its structure to add the diagonal elements.
-
-
To add the diagonal element to the neighbors list, we just need include.self from spdep.
-
+
+
Spatial window average
+
The spatial window average uses row-standardized weights and includes the
+diagonal element. To do this in R, we need to go back to the neighbors
+structure and add the diagonal element before assigning weights. To begin
+we assign k6 to a new variable because we will directly alter its
+structure to add the diagonal elements.
+
+
To add the diagonal element to the neighbors list, we just need include.self
+from spdep.
+
## Neighbour list object:
## Number of regions: 205
## Number of nonzero links: 1435
@@ -690,11 +898,12 @@ Spatial window average
## Average number of links: 7
## Non-symmetric neighbours list
Now we obtain weights with nb2listw
-
k6.weights3 <- nb2listw(k6a)
-
Lastly, we just need to create the lag variable from our weight structure and sale_price variable.
-
lag3 <- lag.listw(k6.weights3, clev.points$sale_price)
-df <- df %>% mutate(lag3 = lag3)
-kable(head(df))
+
k6.weights3 <- nb2listw(k6a)
+
Lastly, we just need to create the lag variable from our weight structure and
+sale_price variable.
+
lag3 <- lag.listw(k6.weights3, clev.points$sale_price)
+df <- df %>% mutate(lag3 = lag3)
+kable(head(df))
-
-
Spatial window sum
-
The spatial window sum is the counter part of the window average, but without using row-standardized weights. To do this we assign binary weights to the neighbor structure that includes the diagonal element.
-
binary.weights2 <- lapply(k6a, function(x) 0*x + 1)
-binary.weights2[1]
+
+
Spatial window sum
+
The spatial window sum is the counter part of the window average, but
+without using row-standardized weights. To do this we assign binary
+weights to the neighbor structure that includes the diagonal element.
+
binary.weights2 <- lapply(k6a, function(x) 0*x + 1)
+binary.weights2[1]
## [[1]]
## [1] 1 1 1 1 1 1
Again we use nb2listw and glist = to explicitly assign weight values.
-
k6.weights4 <- nb2listw(k6a, glist = binary.weights2, style = "B")
+
k6.weights4 <- nb2listw(k6a, glist = binary.weights2, style = "B")
With our new weight structure, we can compute the lag variable with lag.listw.
-
lag4 <- lag.listw(k6.weights4, clev.points$sale_price)
-df <- df %>% mutate(lag4 = lag4)
-kable(head(df))
+
lag4 <- lag.listw(k6.weights4, clev.points$sale_price)
+df <- df %>% mutate(lag4 = lag4)
+kable(head(df))