def test_hill_branch_wt_diversity(primal_graph):
for distances, betas in network_generator():
G = primal_graph.copy()
data_dict = mock.mock_data_dict(G)
landuse_labels = mock.mock_categorical_data(len(data_dict))
# easy version
N_easy = networks.NetworkLayerFromNX(G, distances=distances)
D_easy = layers.DataLayerFromDict(data_dict)
D_easy.assign_to_network(N_easy, max_dist=500)
D_easy.hill_branch_wt_diversity(landuse_labels, qs=[0, 1, 2])
# custom version
N_full = networks.NetworkLayerFromNX(G, distances=distances)
D_full = layers.DataLayerFromDict(data_dict)
D_full.assign_to_network(N_full, max_dist=500)
D_full.compute_landuses(landuse_labels,
mixed_use_keys=['hill_branch_wt'],
qs=[0, 1, 2])
# compare
for d in distances:
for q in [0, 1, 2]:
assert np.allclose(
N_easy.metrics['mixed_uses']['hill_branch_wt'][q][d],
N_full.metrics['mixed_uses']['hill_branch_wt'][q][d],
atol=0.001,
rtol=0)
def test_encode_categorical():
# generate mock data
mock_categorical = mock.mock_categorical_data(50)
classes, class_encodings = layers.encode_categorical(mock_categorical)
for cl in classes:
assert cl in mock_categorical
for idx, label in enumerate(mock_categorical):
assert label in classes
assert classes.index(label) == class_encodings[idx]
def test_mock_categorical_data():
cat_d = mock.mock_categorical_data(50)
assert len(cat_d) == 50
# classes are generated randomly from max number of classes
# i.e. situations do exist where the number of classes will be less than the max permitted
# use large enough max to reduce likelihood of this triggering issue for test
assert len(set(cat_d)) == 10
for c in cat_d:
assert isinstance(c, str)
assert c in string.ascii_lowercase
cat_d = mock.mock_categorical_data(50, num_classes=3)
assert len(set(cat_d)) == 3
# test that an error is raised when requesting more than available max classes per asii_lowercase
with pytest.raises(ValueError):
mock.mock_categorical_data(50,
num_classes=len(string.ascii_lowercase) + 1)
def test_metrics_to_dict(primal_graph):
# create a network layer and run some metrics
N = networks.NetworkLayerFromNX(primal_graph, distances=[500, 1000])
# check with no metrics
metrics_dict = N.metrics_to_dict()
dict_check(metrics_dict, N)
# check with centrality metrics
N.node_centrality(measures=['node_harmonic'])
metrics_dict = N.metrics_to_dict()
dict_check(metrics_dict, N)
# check with data metrics
data_dict = mock.mock_data_dict(primal_graph)
landuse_labels = mock.mock_categorical_data(len(data_dict))
numerical_data = mock.mock_numerical_data(len(data_dict))
metrics_dict = N.metrics_to_dict()
dict_check(metrics_dict, N)
def test_check_categorical_data():
mock_categorical = mock.mock_categorical_data(50)
data_classes, data_encoding = layers.encode_categorical(mock_categorical)
# check for malformed data
# negatives
with pytest.raises(ValueError):
data_encoding[0] = -1
checks.check_categorical_data(data_encoding)
# NaN
with pytest.raises(ValueError):
data_encoding[0] = np.nan
checks.check_categorical_data(data_encoding)
# floats
with pytest.raises(ValueError):
data_encoding_float = np.full(len(data_encoding), np.nan)
data_encoding_float[:] = data_encoding[:].astype(np.float)
data_encoding_float[0] = 1.2345
checks.check_categorical_data(data_encoding_float)
def test_compute_accessibilities(primal_graph):
for distances, betas in network_generator():
G = primal_graph.copy()
data_dict = mock.mock_data_dict(G)
landuse_labels = mock.mock_categorical_data(len(data_dict))
# easy version
N_easy = networks.NetworkLayerFromNX(G, distances=distances)
D_easy = layers.DataLayerFromDict(data_dict)
D_easy.assign_to_network(N_easy, max_dist=500)
D_easy.compute_accessibilities(landuse_labels, ['c'])
# custom version
N_full = networks.NetworkLayerFromNX(G, distances=distances)
D_full = layers.DataLayerFromDict(data_dict)
D_full.assign_to_network(N_full, max_dist=500)
D_full.compute_landuses(landuse_labels, accessibility_keys=['c'])
# compare
for d in distances:
for wt in ['weighted', 'non_weighted']:
assert np.allclose(N_easy.metrics['accessibility'][wt]['c'][d],
N_full.metrics['accessibility'][wt]['c'][d],
atol=0.001,
rtol=0)
###
# INTRO PLOT
G = mock.mock_graph()
plot.plot_nX(G, labels=True, node_size=80, path='images/graph.png', dpi=150)
# INTRO EXAMPLE PLOTS
G = graphs.nX_simple_geoms(G)
G = graphs.nX_decompose(G, 20)
N = networks.NetworkLayerFromNX(G, distances=[400, 800])
N.segment_centrality(measures=['segment_harmonic'])
data_dict = mock.mock_data_dict(G, random_seed=25)
D = layers.DataLayerFromDict(data_dict)
D.assign_to_network(N, max_dist=400)
landuse_labels = mock.mock_categorical_data(len(data_dict), random_seed=25)
D.hill_branch_wt_diversity(landuse_labels, qs=[0])
G_metrics = N.to_networkX()
segment_harmonic_vals = []
mixed_uses_vals = []
for node, data in G_metrics.nodes(data=True):
segment_harmonic_vals.append(
data['metrics']['centrality']['segment_harmonic'][800])
mixed_uses_vals.append(
data['metrics']['mixed_uses']['hill_branch_wt'][0][400])
# custom colourmap
cmap = colors.LinearSegmentedColormap.from_list('cityseer',
['#64c1ff', '#d32f2f'])
segment_harmonic_vals = colors.Normalize()(segment_harmonic_vals)
def test_nX_from_graph_maps(primal_graph):
# also see test_networks.test_to_networkX for tests on implementation via Network layer
# check round trip to and from graph maps results in same graph
# explicitly set live params for equality checks
# graph_maps_from_networkX generates these implicitly if missing
for n in primal_graph.nodes():
primal_graph.nodes[n]['live'] = bool(np.random.randint(0, 1))
# test directly from and to graph maps
node_uids, node_data, edge_data, node_edge_map = graphs.graph_maps_from_nX(primal_graph)
G_round_trip = graphs.nX_from_graph_maps(node_uids, node_data, edge_data, node_edge_map)
assert list(G_round_trip.nodes) == list(primal_graph.nodes)
assert list(G_round_trip.edges) == list(primal_graph.edges)
# check with metrics dictionary
N = networks.NetworkLayerFromNX(primal_graph, distances=[500, 1000])
N.node_centrality(measures=['node_harmonic'])
data_dict = mock.mock_data_dict(primal_graph)
landuse_labels = mock.mock_categorical_data(len(data_dict))
D = layers.DataLayerFromDict(data_dict)
D.assign_to_network(N, max_dist=400)
D.compute_landuses(landuse_labels,
mixed_use_keys=['hill', 'shannon'],
accessibility_keys=['a', 'c'],
qs=[0, 1])
metrics_dict = N.metrics_to_dict()
# without backbone
G_round_trip_data = graphs.nX_from_graph_maps(node_uids,
node_data,
edge_data,
node_edge_map,
metrics_dict=metrics_dict)
for uid, metrics in metrics_dict.items():
assert G_round_trip_data.nodes[uid]['metrics'] == metrics
# with backbone
G_round_trip_data = graphs.nX_from_graph_maps(node_uids,
node_data,
edge_data,
node_edge_map,
networkX_multigraph=primal_graph,
metrics_dict=metrics_dict)
for uid, metrics in metrics_dict.items():
assert G_round_trip_data.nodes[uid]['metrics'] == metrics
# test with decomposed
G_decomposed = graphs.nX_decompose(primal_graph, decompose_max=20)
# set live explicitly
for n in G_decomposed.nodes():
G_decomposed.nodes[n]['live'] = bool(np.random.randint(0, 1))
node_uids_d, node_data_d, edge_data_d, node_edge_map_d = graphs.graph_maps_from_nX(G_decomposed)
G_round_trip_d = graphs.nX_from_graph_maps(node_uids_d, node_data_d, edge_data_d, node_edge_map_d)
assert list(G_round_trip_d.nodes) == list(G_decomposed.nodes)
for n, iter_node_data in G_round_trip.nodes(data=True):
assert n in G_decomposed
assert iter_node_data['live'] == G_decomposed.nodes[n]['live']
assert iter_node_data['x'] == G_decomposed.nodes[n]['x']
assert iter_node_data['y'] == G_decomposed.nodes[n]['y']
assert G_round_trip_d.edges == G_decomposed.edges
# error checks for when using backbone graph:
# mismatching numbers of nodes
corrupt_G = primal_graph.copy()
corrupt_G.remove_node(0)
with pytest.raises(ValueError):
graphs.nX_from_graph_maps(node_uids,
node_data,
edge_data,
node_edge_map,
networkX_multigraph=corrupt_G)
# mismatching node uid
with pytest.raises(KeyError):
corrupt_node_uids = list(node_uids)
corrupt_node_uids[0] = 'boo'
graphs.nX_from_graph_maps(corrupt_node_uids,
node_data,
edge_data,
node_edge_map,
networkX_multigraph=primal_graph)
# missing edge
with pytest.raises(KeyError):
corrupt_primal_graph = primal_graph.copy()
corrupt_primal_graph.remove_edge(0, 1)
graphs.nX_from_graph_maps(node_uids,
node_data,
edge_data,
node_edge_map,
networkX_multigraph=corrupt_primal_graph)
def test_local_agg_time(primal_graph):
"""
Timing tests for landuse and stats aggregations
"""
if 'GITHUB_ACTIONS' in os.environ:
return
os.environ['CITYSEER_QUIET_MODE'] = '1'
# generate node and edge maps
node_uids, node_data, edge_data, node_edge_map, = graphs.graph_maps_from_nX(primal_graph)
# setup data
data_dict = mock.mock_data_dict(primal_graph, random_seed=13)
data_uids, data_map = layers.data_map_from_dict(data_dict)
data_map = data.assign_to_network(data_map, node_data, edge_data, node_edge_map, 500)
# needs a large enough beta so that distance thresholds aren't encountered
distances = np.array([np.inf])
betas = networks.beta_from_distance(distances)
qs = np.array([0, 1, 2])
mock_categorical = mock.mock_categorical_data(len(data_map))
landuse_classes, landuse_encodings = layers.encode_categorical(mock_categorical)
mock_numerical = mock.mock_numerical_data(len(data_dict), num_arrs=2, random_seed=0)
def assign_wrapper():
data.assign_to_network(data_map, node_data, edge_data, node_edge_map, 500)
# prime the function
assign_wrapper()
iters = 20000
# time and report - roughly 5.675
func_time = timeit.timeit(assign_wrapper, number=iters)
print(f'node_cent_wrapper: {func_time} for {iters} iterations')
assert func_time < 10
def landuse_agg_wrapper():
mu_data_hill, mu_data_other, ac_data, ac_data_wt = data.aggregate_landuses(node_data,
edge_data,
node_edge_map,
data_map,
distances,
betas,
mixed_use_hill_keys=np.array([0, 1]),
landuse_encodings=landuse_encodings,
qs=qs,
angular=False)
# prime the function
landuse_agg_wrapper()
iters = 20000
# time and report - roughly 10.10
func_time = timeit.timeit(landuse_agg_wrapper, number=iters)
print(f'node_cent_wrapper: {func_time} for {iters} iterations')
assert func_time < 15
def stats_agg_wrapper():
# compute
data.aggregate_stats(node_data,
edge_data,
node_edge_map,
data_map,
distances,
betas,
numerical_arrays=mock_numerical,
angular=False)
# prime the function
stats_agg_wrapper()
iters = 20000
# time and report - roughly 4.96
func_time = timeit.timeit(stats_agg_wrapper, number=iters)
print(f'segment_cent_wrapper: {func_time} for {iters} iterations')
assert func_time < 10
def test_aggregate_landuses_categorical_components(primal_graph):
# generate node and edge maps
node_uids, node_data, edge_data, node_edge_map, = graphs.graph_maps_from_nX(primal_graph)
# setup data
data_dict = mock.mock_data_dict(primal_graph, random_seed=13)
data_uids, data_map = layers.data_map_from_dict(data_dict)
data_map = data.assign_to_network(data_map, node_data, edge_data, node_edge_map, 500)
# set parameters
betas = np.array([0.02, 0.01, 0.005, 0.0025])
distances = networks.distance_from_beta(betas)
qs = np.array([0, 1, 2])
mock_categorical = mock.mock_categorical_data(len(data_map))
landuse_classes, landuse_encodings = layers.encode_categorical(mock_categorical)
mock_matrix = np.full((len(landuse_classes), len(landuse_classes)), 1)
# set the keys - add shuffling to be sure various orders work
hill_keys = np.arange(4)
np.random.shuffle(hill_keys)
non_hill_keys = np.arange(3)
np.random.shuffle(non_hill_keys)
ac_keys = np.array([1, 2, 5])
np.random.shuffle(ac_keys)
# generate
mu_data_hill, mu_data_other, ac_data, ac_data_wt = data.aggregate_landuses(node_data,
edge_data,
node_edge_map,
data_map,
distances,
betas,
landuse_encodings=landuse_encodings,
qs=qs,
mixed_use_hill_keys=hill_keys,
mixed_use_other_keys=non_hill_keys,
accessibility_keys=ac_keys,
cl_disparity_wt_matrix=mock_matrix,
angular=False)
# hill
hill = mu_data_hill[np.where(hill_keys == 0)][0]
hill_branch_wt = mu_data_hill[np.where(hill_keys == 1)][0]
hill_pw_wt = mu_data_hill[np.where(hill_keys == 2)][0]
hill_disp_wt = mu_data_hill[np.where(hill_keys == 3)][0]
# non hill
shannon = mu_data_other[np.where(non_hill_keys == 0)][0]
gini = mu_data_other[np.where(non_hill_keys == 1)][0]
raos = mu_data_other[np.where(non_hill_keys == 2)][0]
# access non-weighted
ac_1_nw = ac_data[np.where(ac_keys == 1)][0]
ac_2_nw = ac_data[np.where(ac_keys == 2)][0]
ac_5_nw = ac_data[np.where(ac_keys == 5)][0]
# access weighted
ac_1_w = ac_data_wt[np.where(ac_keys == 1)][0]
ac_2_w = ac_data_wt[np.where(ac_keys == 2)][0]
ac_5_w = ac_data_wt[np.where(ac_keys == 5)][0]
# test manual metrics against all nodes
mu_max_unique = len(landuse_classes)
# test against various distances
for d_idx in range(len(distances)):
dist_cutoff = distances[d_idx]
beta = betas[d_idx]
for src_idx in range(len(primal_graph)):
reachable_data, reachable_data_dist, tree_preds = data.aggregate_to_src_idx(src_idx,
node_data,
edge_data,
node_edge_map,
data_map,
dist_cutoff)
# counts of each class type (array length per max unique classes - not just those within max distance)
cl_counts = np.full(mu_max_unique, 0)
# nearest of each class type (likewise)
cl_nearest = np.full(mu_max_unique, np.inf)
# aggregate
a_1_nw = 0
a_2_nw = 0
a_5_nw = 0
a_1_w = 0
a_2_w = 0
a_5_w = 0
# iterate reachable
for data_idx, (reachable, data_dist) in enumerate(zip(reachable_data, reachable_data_dist)):
if not reachable:
continue
cl = landuse_encodings[data_idx]
# double check distance is within threshold
assert data_dist <= dist_cutoff
# update the class counts
cl_counts[cl] += 1
# if distance is nearer, update the nearest distance array too
if data_dist < cl_nearest[cl]:
cl_nearest[cl] = data_dist
# aggregate accessibility codes
if cl == 1:
a_1_nw += 1
a_1_w += np.exp(-beta * data_dist)
elif cl == 2:
a_2_nw += 1
a_2_w += np.exp(-beta * data_dist)
elif cl == 5:
a_5_nw += 1
a_5_w += np.exp(-beta * data_dist)
# assertions
assert ac_1_nw[d_idx, src_idx] == a_1_nw
assert ac_2_nw[d_idx, src_idx] == a_2_nw
assert ac_5_nw[d_idx, src_idx] == a_5_nw
assert ac_1_w[d_idx, src_idx] == a_1_w
assert ac_2_w[d_idx, src_idx] == a_2_w
assert ac_5_w[d_idx, src_idx] == a_5_w
assert hill[0, d_idx, src_idx] == diversity.hill_diversity(cl_counts, 0)
assert hill[1, d_idx, src_idx] == diversity.hill_diversity(cl_counts, 1)
assert hill[2, d_idx, src_idx] == diversity.hill_diversity(cl_counts, 2)
assert hill_branch_wt[0, d_idx, src_idx] == \
diversity.hill_diversity_branch_distance_wt(cl_counts, cl_nearest, 0, beta)
assert hill_branch_wt[1, d_idx, src_idx] == \
diversity.hill_diversity_branch_distance_wt(cl_counts, cl_nearest, 1, beta)
assert hill_branch_wt[2, d_idx, src_idx] == \
diversity.hill_diversity_branch_distance_wt(cl_counts, cl_nearest, 2, beta)
assert hill_pw_wt[0, d_idx, src_idx] == \
diversity.hill_diversity_pairwise_distance_wt(cl_counts, cl_nearest, 0, beta)
assert hill_pw_wt[1, d_idx, src_idx] == \
diversity.hill_diversity_pairwise_distance_wt(cl_counts, cl_nearest, 1, beta)
assert hill_pw_wt[2, d_idx, src_idx] == \
diversity.hill_diversity_pairwise_distance_wt(cl_counts, cl_nearest, 2, beta)
assert hill_disp_wt[0, d_idx, src_idx] == \
diversity.hill_diversity_pairwise_matrix_wt(cl_counts, mock_matrix, 0)
assert hill_disp_wt[1, d_idx, src_idx] == \
diversity.hill_diversity_pairwise_matrix_wt(cl_counts, mock_matrix, 1)
assert hill_disp_wt[2, d_idx, src_idx] == \
diversity.hill_diversity_pairwise_matrix_wt(cl_counts, mock_matrix, 2)
assert shannon[d_idx, src_idx] == diversity.shannon_diversity(cl_counts)
assert gini[d_idx, src_idx] == diversity.gini_simpson_diversity(cl_counts)
assert raos[d_idx, src_idx] == diversity.raos_quadratic_diversity(cl_counts, mock_matrix)
# check that angular is passed-through
# actual angular tests happen in test_shortest_path_tree()
# here the emphasis is simply on checking that the angular instruction gets chained through
# setup dual data
G_dual = graphs.nX_to_dual(primal_graph)
node_labels_dual, node_data_dual, edge_data_dual, node_edge_map_dual = graphs.graph_maps_from_nX(G_dual)
data_dict_dual = mock.mock_data_dict(G_dual, random_seed=13)
data_uids_dual, data_map_dual = layers.data_map_from_dict(data_dict_dual)
data_map_dual = data.assign_to_network(data_map_dual, node_data_dual, edge_data_dual, node_edge_map_dual, 500)
mock_categorical = mock.mock_categorical_data(len(data_map_dual))
landuse_classes_dual, landuse_encodings_dual = layers.encode_categorical(mock_categorical)
mock_matrix = np.full((len(landuse_classes_dual), len(landuse_classes_dual)), 1)
mu_hill_dual, mu_other_dual, ac_dual, ac_wt_dual = data.aggregate_landuses(node_data_dual,
edge_data_dual,
node_edge_map_dual,
data_map_dual,
distances,
betas,
landuse_encodings_dual,
qs=qs,
mixed_use_hill_keys=hill_keys,
mixed_use_other_keys=non_hill_keys,
accessibility_keys=ac_keys,
cl_disparity_wt_matrix=mock_matrix,
angular=True)
mu_hill_dual_sidestep, mu_other_dual_sidestep, ac_dual_sidestep, ac_wt_dual_sidestep = \
data.aggregate_landuses(node_data_dual,
edge_data_dual,
node_edge_map_dual,
data_map_dual,
distances,
betas,
landuse_encodings_dual,
qs=qs,
mixed_use_hill_keys=hill_keys,
mixed_use_other_keys=non_hill_keys,
accessibility_keys=ac_keys,
cl_disparity_wt_matrix=mock_matrix,
angular=False)
assert not np.allclose(mu_hill_dual, mu_hill_dual_sidestep, atol=0.001, rtol=0)
assert not np.allclose(mu_other_dual, mu_other_dual_sidestep, atol=0.001, rtol=0)
assert not np.allclose(ac_dual, ac_dual_sidestep, atol=0.001, rtol=0)
assert not np.allclose(ac_wt_dual, ac_wt_dual_sidestep, atol=0.001, rtol=0)
def test_aggregate_landuses_signatures(primal_graph):
# generate node and edge maps
node_uids, node_data, edge_data, node_edge_map = graphs.graph_maps_from_nX(primal_graph)
# setup data
data_dict = mock.mock_data_dict(primal_graph, random_seed=13)
data_uids, data_map = layers.data_map_from_dict(data_dict)
data_map = data.assign_to_network(data_map, node_data, edge_data, node_edge_map, 500)
# set parameters
betas = np.array([0.02, 0.01, 0.005, 0.0025])
distances = networks.distance_from_beta(betas)
qs = np.array([0, 1, 2])
mock_categorical = mock.mock_categorical_data(len(data_map))
landuse_classes, landuse_encodings = layers.encode_categorical(mock_categorical)
# check that empty land_use encodings are caught
with pytest.raises(ValueError):
data.aggregate_landuses(node_data,
edge_data,
node_edge_map,
data_map,
distances,
betas,
mixed_use_hill_keys=np.array([0]))
# check that unequal land_use encodings vs data map lengths are caught
with pytest.raises(ValueError):
data.aggregate_landuses(node_data,
edge_data,
node_edge_map,
data_map,
distances,
betas,
landuse_encodings=landuse_encodings[:-1],
mixed_use_other_keys=np.array([0]))
# check that no provided metrics flags
with pytest.raises(ValueError):
data.aggregate_landuses(node_data,
edge_data,
node_edge_map,
data_map,
distances,
betas,
landuse_encodings=landuse_encodings)
# check that missing qs flags
with pytest.raises(ValueError):
data.aggregate_landuses(node_data,
edge_data,
node_edge_map,
data_map,
distances,
betas,
mixed_use_hill_keys=np.array([0]),
landuse_encodings=landuse_encodings)
# check that problematic mixed use and accessibility keys are caught
for mu_h_key, mu_o_key, ac_key in [
# negatives
([-1], [1], [1]),
([1], [-1], [1]),
([1], [1], [-1]),
# out of range
([4], [1], [1]),
([1], [3], [1]),
([1], [1], [max(landuse_encodings) + 1]),
# duplicates
([1, 1], [1], [1]),
([1], [1, 1], [1]),
([1], [1], [1, 1])]:
with pytest.raises(ValueError):
data.aggregate_landuses(node_data,
edge_data,
node_edge_map,
data_map,
distances,
betas,
landuse_encodings,
qs=qs,
mixed_use_hill_keys=np.array(mu_h_key),
mixed_use_other_keys=np.array(mu_o_key),
accessibility_keys=np.array(ac_key))
for h_key, o_key in (([3], []), ([], [2])):
# check that missing matrix is caught for disparity weighted indices
with pytest.raises(ValueError):
data.aggregate_landuses(node_data,
edge_data,
node_edge_map,
data_map,
distances,
betas,
landuse_encodings=landuse_encodings,
qs=qs,
mixed_use_hill_keys=np.array(h_key),
mixed_use_other_keys=np.array(o_key))
# check that non-square disparity matrix is caught
mock_matrix = np.full((len(landuse_classes), len(landuse_classes)), 1)
with pytest.raises(ValueError):
data.aggregate_landuses(node_data,
edge_data,
node_edge_map,
data_map,
distances,
betas,
landuse_encodings=landuse_encodings,
qs=qs,
mixed_use_hill_keys=np.array(h_key),
mixed_use_other_keys=np.array(o_key),
cl_disparity_wt_matrix=mock_matrix[:-1])
def test_compute_landuses(primal_graph):
betas = np.array([0.01, 0.005])
distances = networks.distance_from_beta(betas)
# network layer
N = networks.NetworkLayerFromNX(primal_graph, distances=distances)
node_map = N._node_data
edge_map = N._edge_data
node_edge_map = N._node_edge_map
# data layer
data_dict = mock.mock_data_dict(primal_graph)
qs = np.array([0, 1, 2])
D = layers.DataLayerFromDict(data_dict)
# check single metrics independently against underlying for some use-cases, e.g. hill, non-hill, accessibility...
D.assign_to_network(N, max_dist=500)
# generate some mock landuse data
landuse_labels = mock.mock_categorical_data(len(data_dict))
landuse_classes, landuse_encodings = layers.encode_categorical(
landuse_labels)
# compute hill mixed uses
D.compute_landuses(landuse_labels,
mixed_use_keys=['hill_branch_wt'],
qs=qs)
# test against underlying method
data_map = D._data
mu_data_hill, mu_data_other, ac_data, ac_data_wt = data.aggregate_landuses(
node_map,
edge_map,
node_edge_map,
data_map,
distances,
betas,
landuse_encodings,
qs=qs,
mixed_use_hill_keys=np.array([1]))
for q_idx, q_key in enumerate(qs):
for d_idx, d_key in enumerate(distances):
assert np.allclose(
N.metrics['mixed_uses']['hill_branch_wt'][q_key][d_key],
mu_data_hill[0][q_idx][d_idx],
atol=0.001,
rtol=0)
# gini simpson
D.compute_landuses(landuse_labels, mixed_use_keys=['gini_simpson'])
# test against underlying method
data_map = D._data
mu_data_hill, mu_data_other, ac_data, ac_data_wt = data.aggregate_landuses(
node_map,
edge_map,
node_edge_map,
data_map,
distances,
betas,
landuse_encodings,
mixed_use_other_keys=np.array([1]))
for d_idx, d_key in enumerate(distances):
assert np.allclose(N.metrics['mixed_uses']['gini_simpson'][d_key],
mu_data_other[0][d_idx],
atol=0.001,
rtol=0)
# accessibilities
D.compute_landuses(landuse_labels, accessibility_keys=['c'])
# test against underlying method
data_map = D._data
mu_data_hill, mu_data_other, ac_data, ac_data_wt = data.aggregate_landuses(
node_map,
edge_map,
node_edge_map,
data_map,
distances,
betas,
landuse_encodings,
accessibility_keys=np.array([landuse_classes.index('c')]))
for d_idx, d_key in enumerate(distances):
assert np.allclose(
N.metrics['accessibility']['non_weighted']['c'][d_key],
ac_data[0][d_idx],
atol=0.001,
rtol=0)
assert np.allclose(N.metrics['accessibility']['weighted']['c'][d_key],
ac_data_wt[0][d_idx],
atol=0.001,
rtol=0)
# also check the number of returned types for a few assortments of metrics
mixed_uses_hill_types = np.array([
'hill', 'hill_branch_wt', 'hill_pairwise_wt', 'hill_pairwise_disparity'
])
mixed_use_other_types = np.array(
['shannon', 'gini_simpson', 'raos_pairwise_disparity'])
ac_codes = np.array(landuse_classes)
# mixed uses hill
mu_hill_random = np.arange(len(mixed_uses_hill_types))
np.random.shuffle(mu_hill_random)
# mixed uses other
mu_other_random = np.arange(len(mixed_use_other_types))
np.random.shuffle(mu_other_random)
# accessibility
ac_random = np.arange(len(landuse_classes))
np.random.shuffle(ac_random)
# mock disparity matrix
mock_disparity_wt_matrix = np.full(
(len(landuse_classes), len(landuse_classes)), 1)
# not necessary to do all labels, first few should do
for mu_h_min in range(3):
mu_h_keys = np.array(mu_hill_random[mu_h_min:])
for mu_o_min in range(3):
mu_o_keys = np.array(mu_other_random[mu_o_min:])
for ac_min in range(3):
ac_keys = np.array(ac_random[ac_min:])
# in the final case, set accessibility to a single code otherwise an error would be raised
if len(mu_h_keys) == 0 and len(mu_o_keys) == 0 and len(
ac_keys) == 0:
ac_keys = np.array([0])
# randomise order of keys and metrics
mu_h_metrics = mixed_uses_hill_types[mu_h_keys]
mu_o_metrics = mixed_use_other_types[mu_o_keys]
ac_metrics = ac_codes[ac_keys]
# prepare network and compute
N_temp = networks.NetworkLayerFromNX(primal_graph,
distances=distances)
D_temp = layers.DataLayerFromDict(data_dict)
D_temp.assign_to_network(N_temp, max_dist=500)
D_temp.compute_landuses(
landuse_labels,
mixed_use_keys=list(mu_h_metrics) + list(mu_o_metrics),
accessibility_keys=ac_metrics,
cl_disparity_wt_matrix=mock_disparity_wt_matrix,
qs=qs)
# test against underlying method
mu_data_hill, mu_data_other, ac_data, ac_data_wt = \
data.aggregate_landuses(node_map,
edge_map,
node_edge_map,
data_map,
distances,
betas,
landuse_encodings,
qs=qs,
mixed_use_hill_keys=mu_h_keys,
mixed_use_other_keys=mu_o_keys,
accessibility_keys=ac_keys,
cl_disparity_wt_matrix=mock_disparity_wt_matrix)
for mu_h_idx, mu_h_met in enumerate(mu_h_metrics):
for q_idx, q_key in enumerate(qs):
for d_idx, d_key in enumerate(distances):
assert np.allclose(
N_temp.metrics['mixed_uses'][mu_h_met][q_key]
[d_key],
mu_data_hill[mu_h_idx][q_idx][d_idx],
atol=0.001,
rtol=0)
for mu_o_idx, mu_o_met in enumerate(mu_o_metrics):
for d_idx, d_key in enumerate(distances):
assert np.allclose(
N_temp.metrics['mixed_uses'][mu_o_met][d_key],
mu_data_other[mu_o_idx][d_idx],
atol=0.001,
rtol=0)
for ac_idx, ac_met in enumerate(ac_metrics):
for d_idx, d_key in enumerate(distances):
assert np.allclose(N_temp.metrics['accessibility']
['non_weighted'][ac_met][d_key],
ac_data[ac_idx][d_idx],
atol=0.001,
rtol=0)
assert np.allclose(N_temp.metrics['accessibility']
['weighted'][ac_met][d_key],
ac_data_wt[ac_idx][d_idx],
atol=0.001,
rtol=0)
# most integrity checks happen in underlying method, though check here for mismatching labels length and typos
with pytest.raises(ValueError):
D.compute_landuses(landuse_labels[-1], mixed_use_keys=['shannon'])
with pytest.raises(ValueError):
D.compute_landuses(landuse_labels, mixed_use_keys=['spelling_typo'])
# don't check accessibility_labels for typos - because only warning is triggered (not all labels will be in all data)
# check that unassigned data layer flags
with pytest.raises(ValueError):
D_new = layers.DataLayerFromDict(data_dict)
D_new.compute_landuses(landuse_labels, mixed_use_keys=['shannon'])