5 Preparing and Applying Logistic Decay Functions
In this section, I calculate the time between each event and each hexagon and the distance between each event and each hexagon centroid. For each hexagonal grid cell \(c_{i}\) in each month \(t\), I create a vector of spatial distances \(D\) and a vector of temporal distances \(A\) to each event. Events that occur in the future from the time of observation \(t\) receive a missing value. To account for spatial and temporal dependence, logistic decay functions are used to weight each vector to allow the impact of conflict events \(e\) dissipate over time and space.
The impact of an event is assumed to dissipate following a logistic decay function of the general form where x denotes the decaying quantity, age or distance, between the event and centroid. \(k\) determines the slope of the curve and \(\gamma\) determines its inflection point.
\[ w = \frac{1}{1+e^{-k+\gamma x}} \]
The spatial and temporal decay functions are shown below:
The calculations for the distance and age functions are vectorized and use broadcasting to account for dataframe imbalance and thus requires large amounts of memory. Using smaller numerical representations, such as float16, while using less memory, results in very inaccurate distance calculations.
Lastly, our final output, \(exposure\), measures each hexagonal cell’s exposure to intense and not intense fighting. I assume that intense fighting include events where the casualty levels are in the 90th quantile. The exposure of a grid cell \(c_{it}\) to conflict events \(E_{it}\) is computed as the sum over all temporally and spatially weighted events \(J\):
\[ E_{it} = \sum_{j=1}^{J} (w_{d_{ij}} \times w_{a_{jt}}) \]
# spatial distance
def coords_to_vectors(df1, df2):
''' for broadcasting, df1 should be the larger df '''
lon1 = np.array(df1['centroid_long'].tolist()).astype(np.float32)
lat1 = np.array(df1['centroid_lat'].tolist()).astype(np.float32)
lon2 = np.array(df2['Longitude'].tolist()).astype(np.float32)
lat2 = np.array(df2['Latitude'].tolist()).astype(np.float32)
return lon1, lat1, lon2, lat2
def vect_haversine(lon1, lat1, lon2, lat2):
"""
Calculate the great circle distance between two points
on the earth (specified in decimal degrees)
"""
lon1, lat1, lon2, lat2 = map(np.radians, [lon1, lat1, lon2, lat2])
dlon = lon2 - lon1[:, None]
dlat = lat2 - lat1[:, None]
a = np.sin(dlat/2.0)**2 + np.cos(lat1[:, None]) * np.cos(lat2) * np.sin(dlon/2.0)**2
c = 2 * np.arcsin(np.sqrt(a))
km = 6367 * c
return km
# create a vector of spatial distances from each event to each centroid
intense_distance_results = vect_haversine(*coords_to_vectors(df_geo, events_intense))
intense_distance_results.dtype
# create a vector of spatial distances from each event to each centroid
# takes several minutes and a lot of memory
not_intense_distance_results = vect_haversine(*coords_to_vectors(df_geo, events_not_intense))
# need to do the same with time now
def time_to_vectors(df1, df2):
d1 = np.array(df1['time_index'].tolist()).astype(np.float32)
d2 = np.array(df2['month_index'].tolist()).astype(np.float32)
return d1, d2
def vec_time(data1, data2):
age_centroid = data1
age_event = data2
age = np.where(age_event-1 < age_centroid[:, None], age_centroid[:, None] - age_event, np.nan)
return age
# create a vector of age time from each event to each centroid
intense_time_results = vec_time(*time_to_vectors(df_geo, events_intense))
# create a vector of age time from each event to each centroid
not_intense_time_results = vec_time(*time_to_vectors(df_geo, events_not_intense))
################################
### logistic decay function
###############################
# spatial decay
def logistic_spatial_decay(vec, k=7, gamma=-0.35):
''' logistic spatial decay function, params:
k: slope (float)
gamma: inflection point (float)
numerical overflows will occur with large distances,
returning zero; likely bad coordinates '''
w = (1 / (1 + np.exp(-(k + gamma*vec))))
return w
# view function
distance = np.arange(1, 41)
weights_dist = logistic_spatial_decay(distance)
plt.plot(distance, weights_dist)
# apply function
intense_spatial_decay = logistic_spatial_decay(intense_distance_results)
not_intense_spatial_decay = logistic_spatial_decay(not_intense_distance_results)
intense_spatial_decay2 = logistic_spatial_decay(intense_distance_results)
not_intense_spatial_decay2 = logistic_spatial_decay(not_intense_distance_results)
# temporal decay
def logistic_time_decay(vec, k=8, gamma=-2.5):
''' logistic temporal decay function, params:
k: slope (float)
gamma: inflection point (float)
'''
w = (1 / (1 + np.exp(-(k + gamma*vec))))
return w
# view function
time = np.linspace(1, 12) # continuous look
weights_time = logistic_time_decay(time)
plt.plot(time, weights_time)
# apply function
intense_time_decay = logistic_time_decay(intense_time_results)
not_intense_time_decay = logistic_time_decay(not_intense_time_results)
# truncate small values to zero
intense_spatial_decay = np.where(intense_spatial_decay <= 0.05, 0, intense_spatial_decay)
not_intense_spatial_decay = np.where(not_intense_spatial_decay <= 0.05, 0, not_intense_spatial_decay)
intense_time_decay = np.where(intense_time_decay <= 0.05, 0, intense_time_decay)
not_intense_time_decay = np.where(not_intense_time_decay <= 0.05, 0, not_intense_time_decay)
################################
### Exposure
###############################
exposure_intense = np.nanprod(np.dstack((intense_spatial_decay, intense_time_decay)), 2)
exposure_intense = np.sum(exposure_intense, axis=1)
exposure_intense.shape
exposure_not_intense = np.nanprod(np.dstack((not_intense_spatial_decay, not_intense_time_decay)), 2)
exposure_not_intense = np.sum(exposure_not_intense, axis=1)
exposure_not_intense.shape