diff --git a/.github/workflows/ruff_linting.yml b/.github/workflows/ruff_linting.yml new file mode 100644 index 0000000..b866eac --- /dev/null +++ b/.github/workflows/ruff_linting.yml @@ -0,0 +1,18 @@ +name: ruff linting +on: push +jobs: + build: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + - name: Install Python + uses: actions/setup-python@v5 + with: + python-version: "3.11" + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install ruff==0.6.9 + # Update output format to enable automatic inline annotations. + - name: Run Ruff + run: ruff check --output-format=github . \ No newline at end of file diff --git a/ruff.toml b/ruff.toml new file mode 100644 index 0000000..551a2e2 --- /dev/null +++ b/ruff.toml @@ -0,0 +1,24 @@ + +line-length = 120 + +[lint] +select = [ + # pycodestyle + "E", + # Pyflakes + "F", + # pyupgrade + "UP", + # flake8-bugbear + "B", + # flake8-simplify + "SIM", + # isort + "I", + # pycodestyle + "D" +] + +[lint.pydocstyle] +# Use Google-style docstrings. +convention = "google" diff --git a/visualization/predictors/gpmap.py b/visualization/predictors/gpmap.py new file mode 100644 index 0000000..358c29a --- /dev/null +++ b/visualization/predictors/gpmap.py @@ -0,0 +1,154 @@ +import geopandas as gpd +import matplotlib.colors as colors +import numpy as np +import pandas as pd +import rasterio +import rasterio.mask +import rasterio.plot +from matplotlib import cm +from matplotlib import pyplot as plt +from rasterio.control import GroundControlPoint as GCP +from rasterio.crs import CRS +from rasterio.transform import from_gcps +from shapely.geometry import Point, Polygon +from shapely.ops import unary_union +from shapely.validation import make_valid +from sklearn.base import BaseEstimator, RegressorMixin +from tqdm.auto import tqdm +import time +import os +import pickle +from utils.utils_data import get_points +from models import MapBasedModel +from utils.utils_models import fit_gpr_silent +import glob + +class GPMap(MapBasedModel): + def __init__(self): + self.gpr_path = "models/kernel.pkl" + self.points_path = "dump.sqlite" + + with open(self.gpr_path, "rb") as file: + self.gpr = pickle.load(file) + + super().__init__(method=type(self.gpr).__name__, region="world", resolution=10, version="prod", verbose=False) + + files = glob.glob(f"intermediate/map_{self.method}_{self.region}_{self.resolution}_{self.version}*.txt") + if len(files) == 0: + raise FileNotFoundError("No base map calculated so far.") + else: + latest_date = pd.Timestamp.min + for file in files: + date = pd.Timestamp(file.split("_")[-1].split(".")[0]) + if date > latest_date: + latest_date = date + self.old_map_path = file + + self.begin = latest_date + + self.batch_size = 10000 + self.today = pd.Timestamp("2024-3-30") + self.map_path = f"intermediate/map_{self.method}_{self.region}_{self.resolution}_{self.version}_{self.today.date()}.txt" + + self.recalc_radius = 800000 # TODO: determine from model largest influence radius + + def recalc_map(self): + """Recalculate the map with the current Gaussian Process model. + + Overrides the stored np.array raster of the map. + """ + # fit model to new data points + + self.points = get_points(self.points_path, until=self.today) + self.points["lon"] = self.points.geometry.x + self.points["lat"] = self.points.geometry.y + + X = self.points[["lon", "lat"]].values + y = self.points["wait"].values + + self.gpr.regressor.optimizer = None + self.gpr = fit_gpr_silent(self.gpr, X, y) + + # recalc the old map + + self.raw_raster = np.loadtxt(self.old_map_path) + + self.get_map_grid() + self.get_recalc_raster() + + print("Compute pixels that are expected to differ...") + start = time.time() + to_predict = [] + pixels_to_predict = [] + for x, vertical_line in tqdm( + enumerate(self.grid.transpose()), total=len(self.grid.transpose()) + ): + for y, coords in enumerate(vertical_line): + if self.recalc_landmass[y][x] == 0: + continue + this_point = [float(coords[0]), float(coords[1])] + to_predict.append(this_point) + pixels_to_predict.append((y, x)) + # batching the model calls + if len(to_predict) == self.batch_size: + prediction = model.predict(np.array(to_predict), return_std=False) + for i, (y, x) in enumerate(pixels_to_predict): + self.raw_raster[y][x] = prediction[i] + + to_predict = [] + pixels_to_predict = [] + + prediction = model.predict(np.array(to_predict), return_std=False) + for i, (y, x) in enumerate(pixels_to_predict): + self.raw_raster[y][x] = prediction[i] + + print(f"Time elapsed to compute full map: {time.time() - start}") + print( + f"For map of shape: {self.raw_raster.shape} that is {self.raw_raster.shape[0] * self.raw_raster.shape[1]} pixels and an effective time per pixel of {(time.time() - start) / (self.raw_raster.shape[0] * self.raw_raster.shape[1])} seconds" + ) + print((f"Only {recalc_landmass.sum()} pixels were recalculated. That is {recalc_landmass.sum() / (self.raw_raster.shape[0] * self.raw_raster.shape[1]) * 100}% of the map.")) + print(f"And time per recalculated pixel was {(time.time() - start) / recalc_landmass.sum()} seconds") + + np.savetxt(self.map_path, self.raw_raster) + self.save_as_raster() + + + def get_recalc_raster(self): + """Creats 2d np.array of raster where only pixels that are 1 should be recalculated.""" + def pixel_from_point(point) -> tuple[int, int]: + lats = map.Y.transpose()[0] + lat_index = None + for i, lat in enumerate(lats): + if lat >= point["lat"] and point["lat"] >= lats[i+1]: + lat_index = i + break + + lons = map.X[0] + lon_index = None + for i, lon in enumerate(lons): + if lon <= point["lon"] and point["lon"] <= lons[i+1]: + lon_index = i + break + + return (lat_index, lon_index) + + recalc_radius_pixels = int(np.ceil(abs(self.recalc_radius / (self.grid[0][0][0] - self.grid[0][0][1])))) + + self.recalc_raster = np.zeros(self.grid.shape[1:]) + self.recalc_raster.shape + new_points = get_points(self.points_path, begin=self.begin, until=self.today) + for i, point in new_points.iterrows(): + lat_pixel, lon_pixel = pixel_from_point(point) + + for i in range(lat_pixel - recalc_radius_pixels, lat_pixel + recalc_radius_pixels): + for j in range(lon_pixel - recalc_radius_pixels, lon_pixel + recalc_radius_pixels): + if i < 0 or j < 0 or i >= self.recalc_raster.shape[0] or j >= self.recalc_raster.shape[1]: + continue + self.recalc_raster[i, j] = 1 + + print("Report reduction of rasters.") + print(self.recalc_raster.sum(), self.recalc_raster.shape[0] * self.recalc_raster.shape[1], self.recalc_raster.sum() / (self.recalc_raster.shape[0] * self.recalc_raster.shape[1])) + self.get_landmass_raster() + self.recalc_raster = self.recalc_raster * self.landmass_raster + print(self.landmass_raster.sum(), self.landmass_raster.shape[0] * self.landmass_raster.shape[1], self.landmass_raster.sum() / (self.landmass_raster.shape[0] * self.landmass_raster.shape[1])) + print(self.recalc_raster.sum(), self.recalc_raster.shape[0] * self.recalc_raster.shape[1], self.recalc_raster.sum() / (self.recalc_raster.shape[0] * self.recalc_raster.shape[1])) diff --git a/visualization/predictors/intermediate/map_asia.png b/visualization/predictors/intermediate/map_asia.png deleted file mode 100644 index 8479c19..0000000 Binary files a/visualization/predictors/intermediate/map_asia.png and /dev/null differ diff --git a/visualization/predictors/intermediate/map_australia.png b/visualization/predictors/intermediate/map_australia.png deleted file mode 100644 index e5dfb2a..0000000 Binary files a/visualization/predictors/intermediate/map_australia.png and /dev/null differ diff --git a/visualization/predictors/maps/TransformedTargetRegressorWithUncertainty_world_10.png b/visualization/predictors/maps/TransformedTargetRegressorWithUncertainty_world_10.png new file mode 100644 index 0000000..a7dfa49 Binary files /dev/null and b/visualization/predictors/maps/TransformedTargetRegressorWithUncertainty_world_10.png differ diff --git a/visualization/predictors/models.py b/visualization/predictors/models.py index 5f4028b..a905735 100644 --- a/visualization/predictors/models.py +++ b/visualization/predictors/models.py @@ -16,6 +16,9 @@ from sklearn.base import BaseEstimator, RegressorMixin from tqdm.auto import tqdm import time +import os +import pickle +from utils.utils_data import get_points tqdm.pandas() @@ -57,9 +60,12 @@ def __init__( self.version = version self.verbose = verbose + os.makedirs("temp", exist_ok=True) + self.map_boundary = self.get_map_boundary() self.rasterio_path = f"intermediate/map_{self.method}_{self.region}_{self.resolution}_{self.version}.tif" self.map_path = f"intermediate/map_{method}_{region}_{resolution}_{version}.txt" + self.landmass_path = "temp/landmass.tif" def get_map_boundary(self): @@ -119,7 +125,7 @@ def map_to_polygon(self): return polygon - def save_as_raster(self): + def save_as_rasterio(self): """Saves as .tif raster for rasterio.""" polygon_vertices_x, polygon_vertices_y, pixel_width, pixel_height = ( @@ -170,11 +176,64 @@ def save_as_raster(self): ) as destination: destination.write(self.raw_raster, 1) - self.raster = rasterio.open(self.rasterio_path) - - return map + self.rasterio_raster = rasterio.open(self.rasterio_path) def get_landmass_raster(self): + """Creates raster of landmass as np.array""" + self.landmass_raster = np.ones(self.grid.shape[1:]) + + polygon_vertices_x, polygon_vertices_y, pixel_width, pixel_height = ( + self.define_raster() + ) + + # handling special case when map spans over the 180 degree meridian + if polygon_vertices_x[0] > 0 and polygon_vertices_x[2] < 0: + polygon_vertices_x[2] = 2 * MERIDIAN + polygon_vertices_x[2] + polygon_vertices_x[3] = 2 * MERIDIAN + polygon_vertices_x[3] + + # https://gis.stackexchange.com/questions/425903/getting-rasterio-transform-affine-from-lat-and-long-array + + # lower/upper - left/right + ll = (polygon_vertices_x[0], polygon_vertices_y[0]) + ul = (polygon_vertices_x[1], polygon_vertices_y[1]) # in lon, lat / x, y order + ur = (polygon_vertices_x[2], polygon_vertices_y[2]) + lr = (polygon_vertices_x[3], polygon_vertices_y[3]) + cols, rows = pixel_width, pixel_height + + # ground control points + gcps = [ + GCP(0, 0, *ul), + GCP(0, cols, *ur), + GCP(rows, 0, *ll), + GCP(rows, cols, *lr), + ] + + # seems to need the vertices of the map polygon + transform = from_gcps(gcps) + + # cannot use np.float128 to write to tif + self.landmass_raster = self.landmass_raster.astype(np.float64) + + # save the colored raster using the above transform + # important: rasterio requires [0,0] of the raster to be in the upper left corner and [rows, cols] in the lower right corner + # TODO find out why raster is getting smaller in x direction when stored as tif (e.g. 393x700 -> 425x700) + with rasterio.open( + self.landmass_path, + "w", + driver="GTiff", + height=self.landmass_raster.shape[0], + width=self.landmass_raster.shape[1], + count=1, + crs=CRS.from_epsg(3857), + transform=transform, + dtype=self.landmass_raster.dtype, + ) as destination: + destination.write(self.landmass_raster, 1) + + landmass_rasterio = rasterio.open(self.landmass_path) + + nodata = 0 + countries = gpd.read_file( "map_features/countries/ne_110m_admin_0_countries.shp" ) @@ -182,52 +241,15 @@ def get_landmass_raster(self): countries = countries[countries.NAME != "Antarctica"] country_shapes = countries.geometry country_shapes = country_shapes.apply(lambda x: make_valid(x)) - self.landmass_raster = np.zeros(map.grid.shape[1:]) - for x, vertical_line in tqdm(enumerate(map.grid.transpose()), total=len(map.grid.transpose())): - for y, coords in enumerate(vertical_line): - this_point = Point(float(coords[0]), float(coords[1])) - self.landmass_raster[y][x] = 1 if any([country_shape.contains(this_point) for country_shape in country_shapes]) else 0 - - def get_recalc_raster(self): - - def pixel_from_point(point) -> tuple[int, int]: - lats = map.Y.transpose()[0] - lat_index = None - for i, lat in enumerate(lats): - if lat >= point["lat"] and point["lat"] >= lats[i+1]: - lat_index = i - break - - lons = map.X[0] - lon_index = None - for i, lon in enumerate(lons): - if lon <= point["lon"] and point["lon"] <= lons[i+1]: - lon_index = i - break - - return (lat_index, lon_index) - - recalc_radius = 800000 # TODO: determine from model largest influence radius - recalc_radius_pixels = int(np.ceil(abs(recalc_radius / (map.grid[0][0][0] - map.grid[0][0][1])))) - - self.recalc_raster = np.zeros(map.grid.shape[1:]) - self.recalc_raster.shape - for i, point in points.iterrows(): - lat_pixel, lon_pixel = pixel_from_point(point) - - for i in range(lat_pixel - recalc_radius_pixels, lat_pixel + recalc_radius_pixels): - for j in range(lon_pixel - recalc_radius_pixels, lon_pixel + recalc_radius_pixels): - if i < 0 or j < 0 or i >= self.recalc_raster.shape[0] or j >= self.recalc_raster.shape[1]: - continue - self.recalc_raster[i, j] = 1 - - print("Report reduction of rasters.") - print(self.recalc_raster.sum(), self.recalc_raster.shape[0] * self.recalc_raster.shape[1], self.recalc_raster.sum() / (self.recalc_raster.shape[0] * self.recalc_raster.shape[1])) - self.get_landmass_raster() - self.recalc_raster = self.recalc_raster * self.landmass_raster - print(self.landmass_raster.sum(), self.landmass_raster.shape[0] * self.landmass_raster.shape[1], self.landmass_raster.sum() / (self.landmass_raster.shape[0] * self.landmass_raster.shape[1])) - print(self.recalc_raster.sum(), self.recalc_raster.shape[0] * self.recalc_raster.shape[1], self.recalc_raster.sum() / (self.recalc_raster.shape[0] * self.recalc_raster.shape[1])) + out_image, out_transform = rasterio.mask.mask( + landmass_rasterio, country_shapes, nodata=nodata + ) + + self.landmass_raster = out_image[0] + + # cleanup + os.remove(self.landmass_path) def get_map_grid(self) -> np.array: """Create pixel grid for map.""" @@ -737,7 +759,7 @@ def fit( recompute=True, no_data_threshold=0.00000001, ): - self.raster = None + self.rasterio_raster = None self.raw_raster: np.array = None self.points = X @@ -806,7 +828,7 @@ def fit( np.savetxt(f"intermediate/map_{self.region}.txt", Z) self.raw_raster = Z - self.save_as_raster() + self.save_as_rasterio() return self @@ -818,8 +840,8 @@ def predict(self, X): for lon, lat in X: # transform the lat/lon to the raster's coordinate system - x, y = self.raster.index(lon, lat) + x, y = self.rasterio_raster.index(lon, lat) # read the raster at the given coordinates - predictions.append(self.raster.read(1)[x, y]) + predictions.append(self.rasterio_raster.read(1)[x, y]) - return np.array(predictions) + return np.array(predictions) \ No newline at end of file diff --git a/visualization/predictors/year.ipynb b/visualization/predictors/year.ipynb index abc388c..035de1c 100644 --- a/visualization/predictors/year.ipynb +++ b/visualization/predictors/year.ipynb @@ -2,13 +2,17 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import pandas as pd\n", "import numpy as np\n", - "import seaborn as sns" + "import seaborn as sns\n", + "import sys\n", + "sys.path.append('./utils')\n", + "from utils_imports import *\n", + "from gpmap import GPMap" ] }, { @@ -20,18 +24,7 @@ }, { "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "import sys\n", - "sys.path.append('./utils')\n", - "from utils_imports import *" - ] - }, - { - "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -44,7 +37,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -123,7 +116,7 @@ "4 -4.116196e+06 -6.029002e+06 10.0 POINT (-6029002.261 -4116195.732)" ] }, - "execution_count": 5, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -137,7 +130,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "metadata": {}, "outputs": [ { @@ -146,7 +139,7 @@ "8" ] }, - "execution_count": 6, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -160,73 +153,135 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "countries = gpd.read_file(\n", - " \"map_features/countries/ne_110m_admin_0_countries.shp\"\n", - ")\n", - "countries = countries.to_crs(epsg=3857)\n", - "countries = countries[countries.NAME != \"Antarctica\"]\n", - "country_shapes = countries.geometry\n", - "country_shapes = country_shapes.apply(lambda x: make_valid(x))" - ] - }, - { - "cell_type": "code", - "execution_count": 8, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ - "landmass = np.zeros(map.grid.shape[1:])" + "map.get_landmass_raster()\n", + "landmass = map.landmass_raster" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 6, "metadata": {}, "outputs": [ { "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "131f5d9932714d29adee1db4825e9adc", - "version_major": 2, - "version_minor": 0 - }, + "image/png": "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", "text/plain": [ - " 0%| | 0/360 [00:00" ] }, "metadata": {}, "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(136, 360)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "for x, vertical_line in tqdm(enumerate(map.grid.transpose()), total=len(map.grid.transpose())):\n", - " for y, coords in enumerate(vertical_line):\n", - " this_point = Point(float(coords[0]), float(coords[1]))\n", - " landmass[y][x] = 1 if any([country_shape.contains(this_point) for country_shape in country_shapes]) else 0" + "plt.imshow(landmass, cmap='viridis', interpolation='nearest')\n", + "\n", + "# Add a color bar to show the scale\n", + "plt.colorbar()\n", + "\n", + "# Add labels for better understanding (optional)\n", + "plt.title(\"Heatmap of 2D Array\")\n", + "plt.xlabel(\"X-axis\")\n", + "plt.ylabel(\"Y-axis\")\n", + "\n", + "# Show the plot\n", + "plt.show()\n", + "landmass.shape" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'MapBasedModel' object has no attribute 'save_as_raster'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[20], line 5\u001b[0m\n\u001b[1;32m 1\u001b[0m m \u001b[38;5;241m=\u001b[39m MapBasedModel(method\u001b[38;5;241m=\u001b[39mmethod, region\u001b[38;5;241m=\u001b[39mregion, resolution\u001b[38;5;241m=\u001b[39mres, version\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtif\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 3\u001b[0m m\u001b[38;5;241m.\u001b[39mraw_raster \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39mones(\u001b[38;5;28mmap\u001b[39m\u001b[38;5;241m.\u001b[39mgrid\u001b[38;5;241m.\u001b[39mshape[\u001b[38;5;241m1\u001b[39m:])\n\u001b[0;32m----> 5\u001b[0m \u001b[43mm\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msave_as_raster\u001b[49m()\n\u001b[1;32m 7\u001b[0m nodata \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m\n\u001b[1;32m 8\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m rasterio\u001b[38;5;241m.\u001b[39mopen(m\u001b[38;5;241m.\u001b[39mrasterio_path) \u001b[38;5;28;01mas\u001b[39;00m heatmap:\n", + "\u001b[0;31mAttributeError\u001b[0m: 'MapBasedModel' object has no attribute 'save_as_raster'" + ] + } + ], + "source": [ + "m = MapBasedModel(method=method, region=region, resolution=res, version=\"tif\")\n", + "\n", + "m.raw_raster = np.ones(map.grid.shape[1:])\n", + "\n", + "m.save_as_raster()\n", + "\n", + "nodata = 0\n", + "with rasterio.open(m.rasterio_path) as heatmap:\n", + " start = time.time()\n", + " max_map_wait = heatmap.read().max()\n", + " min_map_wait = heatmap.read().min()\n", + "\n", + " out_image, out_transform = rasterio.mask.mask(\n", + " heatmap, country_shapes, nodata=nodata\n", + " )\n", + " out_meta = heatmap.meta\n", + " print(f\"Time elapsed to transform heatmap: {time.time() - start}\")\n", + "\n", + "out_image[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Open the GeoTIFF file\n", + "with rasterio.open(new_map_path) as src:\n", + " # Read the first band (assuming single-band raster, adjust for multi-band)\n", + " numpy_array = src.read(1)" + ] + }, + { + "cell_type": "code", + "execution_count": null, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "(136, 360)" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ - "plt.imshow(landmass, cmap='viridis', interpolation='nearest')\n", + "plt.imshow(numpy_array, cmap='viridis', interpolation='nearest')\n", "\n", "# Add a color bar to show the scale\n", "plt.colorbar()\n", @@ -237,7 +292,8 @@ "plt.ylabel(\"Y-axis\")\n", "\n", "# Show the plot\n", - "plt.show()" + "plt.show()\n", + "numpy_array.shape" ] }, { @@ -414,71 +470,6 @@ "stop" ] }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "fmin_l_bfgs_b\n", - "None\n", - "Compute rows of pixels...\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "d39beef7c93d4d8fbf43c12e4390cdec", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/360 [00:00 1\u001b[0m \u001b[38;5;28;43mmap\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mbuild_map\u001b[49m()\n", + "\u001b[0;31mAttributeError\u001b[0m: 'function' object has no attribute 'build_map'" + ] + } + ], + "source": [ + "map.build_map()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "res = 10\n", + "method = \"TransformedTargetRegressorWithUncertainty\"\n", + "tolerance = 3.0\n", + "recalc_radius = 800000\n", + "region = \"world\"" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
latlonwaitgeometry
0-5.688317e+061.867128e+075.0POINT (18671284.843 -5688317.046)
1-4.699017e+06-7.583577e+0615.0POINT (-7583577.497 -4699016.755)
2-4.602671e+061.961982e+077.0POINT (19619822.183 -4602670.687)
3-4.148354e+06-6.127095e+0610.0POINT (-6127094.551 -4148353.673)
4-4.116196e+06-6.029002e+0610.0POINT (-6029002.261 -4116195.732)
\n", + "
" + ], + "text/plain": [ + " lat lon wait geometry\n", + "0 -5.688317e+06 1.867128e+07 5.0 POINT (18671284.843 -5688317.046)\n", + "1 -4.699017e+06 -7.583577e+06 15.0 POINT (-7583577.497 -4699016.755)\n", + "2 -4.602671e+06 1.961982e+07 7.0 POINT (19619822.183 -4602670.687)\n", + "3 -4.148354e+06 -6.127095e+06 10.0 POINT (-6127094.551 -4148353.673)\n", + "4 -4.116196e+06 -6.029002e+06 10.0 POINT (-6029002.261 -4116195.732)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "points = get_points(\"dump.sqlite\", begin=pd.Timestamp(\"2024-1-30\"), until=pd.Timestamp(\"2024-3-30\"))\n", + "points[\"lon\"] = points.geometry.x\n", + "points[\"lat\"] = points.geometry.y\n", + "points.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "72" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "map = MapBasedModel(method=method, region=region, resolution=res, version=\"diff_mar\")\n", + "map.get_map_grid()\n", + "recalc_radius_pixels = int(np.ceil(abs(recalc_radius / (map.grid[0][0][0] - map.grid[0][0][1]))))\n", + "recalc_radius_pixels" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "map.get_landmass_raster()\n", + "landmass = map.landmass_raster" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(landmass, cmap='viridis', interpolation='nearest')\n", + "\n", + "# Add a color bar to show the scale\n", + "plt.colorbar()\n", + "\n", + "# Add labels for better understanding (optional)\n", + "plt.title(\"Heatmap of 2D Array\")\n", + "plt.xlabel(\"X-axis\")\n", + "plt.ylabel(\"Y-axis\")\n", + "\n", + "# Show the plot\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def pixel_from_point(point) -> tuple[int, int]:\n", + " lats = map.Y.transpose()[0]\n", + " lat_index = None\n", + " for i, lat in enumerate(lats):\n", + " if lat >= point[\"lat\"] and point[\"lat\"] >= lats[i+1]:\n", + " lat_index = i\n", + " break\n", + "\n", + " lons = map.X[0]\n", + " lon_index = None\n", + " for i, lon in enumerate(lons):\n", + " if lon <= point[\"lon\"] and point[\"lon\"] <= lons[i+1]:\n", + " lon_index = i\n", + " break\n", + "\n", + " return (lat_index, lon_index)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(1360, 3600)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "recalc = np.zeros(map.grid.shape[1:])\n", + "recalc.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "for i, point in points.iterrows():\n", + " lat_pixel, lon_pixel = pixel_from_point(point)\n", + "\n", + " for i in range(lat_pixel - recalc_radius_pixels, lat_pixel + recalc_radius_pixels):\n", + " for j in range(lon_pixel - recalc_radius_pixels, lon_pixel + recalc_radius_pixels):\n", + " if i < 0 or j < 0 or i >= recalc.shape[0] or j >= recalc.shape[1]:\n", + " continue\n", + " recalc[i, j] = 1" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(recalc, cmap='viridis', interpolation='nearest')\n", + "\n", + "# Add a color bar to show the scale\n", + "plt.colorbar()\n", + "\n", + "# Add labels for better understanding (optional)\n", + "plt.title(\"Heatmap of 2D Array\")\n", + "plt.xlabel(\"X-axis\")\n", + "plt.ylabel(\"Y-axis\")\n", + "\n", + "# Show the plot\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "recalc_landmass = recalc * landmass" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiwAAAGTCAYAAAALA0nUAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABHG0lEQVR4nO3deVxU5f4H8M8AMqg0LCIgioLmvoDilXBPSUwzzcpdyZ/7FTXRVErBrTAt05IyTcV701y6aWWEEYrmlfSKklqmqSimDmoKKC7gzPP7w8u5jAw4w8wwc5jP+/U6r+Kc55zzPBxkvnyf5SiEEAJERERENszB2hUgIiIiehIGLERERGTzGLAQERGRzWPAQkRERDaPAQsRERHZPAYsREREZPMYsBAREZHNY8BCRERENo8BCxEREdk8BixERERk8xiwEBERkcH279+Pfv36wc/PDwqFAjt37nziOWlpaWjXrh2USiWefvppJCYmGn1fBixERERksIKCAgQFBSEhIcGg8llZWejbty+effZZZGZm4vXXX8fYsWOxe/duo+6r4MsPiYiIqCIUCgV27NiBAQMGlFlm9uzZ+O6773Dy5Elp35AhQ5Cbm4vk5GSD7+VkSkWJiIjIOu7fv4/CwkKTryOEgEKh0NmnVCqhVCpNvjYApKenIzw8XGdfREQEXn/9daOuw4CFiIhIZu7fv4/ABq5QX9OYfC1XV1fcuXNHZ19cXBzmz59v8rUBQK1Ww8fHR2efj48P8vPzce/ePVSvXt2g6zBgISIikpnCwkKor2mQldEAqqcqPhw1/7YWgSEXcenSJahUKmm/ubIr5sSAhYiISKZUTzmYFLBI11GpdAIWc/L19UVOTo7OvpycHKhUKoOzKwADFiIiItnSCC00Jkyd0Qit+SpThrCwMCQlJensS0lJQVhYmFHX4bRmIiIimdJCmLwZ686dO8jMzERmZiaAR9OWMzMzkZ2dDQCIiYnBqFGjpPITJ07E+fPnMWvWLPz+++/4+OOPsW3bNkyfPt2o+zJgISIiIoMdOXIEbdu2Rdu2bQEA0dHRaNu2LWJjYwEAV69elYIXAAgMDMR3332HlJQUBAUF4f3338dnn32GiIgIo+7LdViIiIhkJj8/H25ubrhyup7Jg279mv6JvLw8i41hMReOYSEiIpIpjRDQmJB3MOXcysYuISIiIrJ5zLAQERHJVEUHzpY8Xy4YsBAREcmUFgIaBixERERky+wpw8IxLERERGTzmGEhIiKSKXuaJcSAhYiISKa0/91MOV8u2CVERERENo8ZFiIiIpnSmDhLyJRzKxsDFiIiIpnSCJj4tmbz1cXS2CVERERENo8ZFiIiIpmyp0G3DFiIiIhkSgsFNFCYdL5csEuIiIiIbB4zLERERDKlFY82U86XCwYsREREMqUxsUvIlHMrGwMWIiIimbKngIVjWIiIiMjmMcNCREQkU1qhgFaYMEvIhHMrGwMWIiIimWKXEBEREZENYYaFiIhIpjRwgMaE3IPGjHWxNAYsREREMiVMHMMiZDSGhV1CREREZPOYYSEiIpIpexp0y4CFiIhIpjTCARphwhgWGS3Nzy4hIiIisnnMsBAREcmUFgpoTcg9aCGfFAsDFiIiIpniGBYiIiKyeaaPYZFPhoVjWIiIiMjmMcNCREQkU4/GsJjw8kN2CREREZGlaU1cml9Og27ZJUREREQ2jxkWIiIimbKnQbcMWIiIiGRKCwe7WYeFXUJERERk85hhISIikimNUEAjTFg4zoRzKxsDFiIiIpnSmDhLSMMuISIiIiLzYYaFiIhIprTCAVoTZglpOUuIiIiILM2euoQYsBAREcmUFqYNnNWaryoWxzEsREREZPOYYSEiIpIp0xeOk0/eggELERGRTJm+NL98Ahb51JSIiIjsFjMsREREMqWFAlqYMuiWK90SERGRhbFLiIiIiMiGMMNCREQkU6YvHCefvAUDFiIiIpnSCgW0piwcJ6O3NcsntCIiIiK7xQwLERGRTGlN7BLiwnFERERkcaa/rZkBCxEREVmYBgpoTFhLxZRzK5t8QisiIiKyW8ywEBERyRS7hIiIiMjmaWBat47GfFWxOPmEVkRERGS3mGEhIiKSKXYJERERkc3jyw+JiIiIypCQkICAgAC4uLggNDQUhw8fLrf8ihUr0LRpU1SvXh3+/v6YPn067t+/b9Q9GbAQERHJlIACWhM2UYEBu1u3bkV0dDTi4uJw9OhRBAUFISIiAteuXdNbfvPmzZgzZw7i4uJw6tQprFu3Dlu3bsWbb75p1H0ZsBAREclUcZeQKZuxli9fjnHjxmH06NFo0aIFVq9ejRo1amD9+vV6yx88eBCdOnXCsGHDEBAQgF69emHo0KFPzMo8jgELERGRncvPz9fZHjx4oLdcYWEhMjIyEB4eLu1zcHBAeHg40tPT9Z7TsWNHZGRkSAHK+fPnkZSUhD59+hhVRw66JSIikimtUEArKr4OS/G5/v7+Ovvj4uIwf/78UuVv3LgBjUYDHx8fnf0+Pj74/fff9d5j2LBhuHHjBjp37gwhBB4+fIiJEyca3SXEgIWIiEimNCa+rbn43EuXLkGlUkn7lUqlyXUrlpaWhnfeeQcff/wxQkNDcfbsWUybNg2LFi3CvHnzDL4OAxYiIiKZMleGRaVS6QQsZfHy8oKjoyNycnJ09ufk5MDX11fvOfPmzcPIkSMxduxYAEDr1q1RUFCA8ePH46233oKDg2EBF8ewEBERkUGcnZ0REhKC1NRUaZ9Wq0VqairCwsL0nnP37t1SQYmjoyMAQAhh8L2ZYSEiIpIpLRygNSH3UJFzo6OjERkZifbt26NDhw5YsWIFCgoKMHr0aADAqFGjULduXcTHxwMA+vXrh+XLl6Nt27ZSl9C8efPQr18/KXAxBAMWIiIimdIIBTQmdAlV5NzBgwfj+vXriI2NhVqtRnBwMJKTk6WBuNnZ2ToZlblz50KhUGDu3Lm4fPkyateujX79+uHtt9826r4KYUw+hoiIiKwuPz8fbm5umPTTQChdq1X4Og/uFOGTLl8hLy/PoDEs1sQMCxERkUyZa9CtHDBgISIikilh4tuaBV9+SERERGQ+zLAQERHJlAYKaCrwAsOS58sFAxYiIiKZ0grTxqFoZTTthl1CREREZPOYYSEiIpIprYmDbk05t7LJp6ZEJCvLli1Dw4YN4ejoiODgYGtXh6hK0kJh8iYXDFjILiQmJkKhUODIkSN6j3fv3h2tWrWyaB2SkpL0vq69Kvrhhx8wa9YsdOrUCRs2bMA777xTZtmvvvoKgwcPRsOGDVGjRg00bdoUM2bMQG5ubqmyCoVC2pycnODp6YmQkBBMmzYNv/32m9H11Gg08PPzg0KhwPfff2/0+UTWVrzSrSmbXLBLiKiSJCUlISEhwS6Clj179sDBwQHr1q2Ds7NzuWXHjx8PPz8/jBgxAvXr18eJEyewatUqJCUl4ejRo6hevbpO+eeeew6jRo2CEAJ5eXn45ZdfsHHjRnz88cd49913ER0dbVQ9r169ioCAAGzatAnPP/98hdpLRJbHgIWIzO7atWuoXr36E4MVAPjyyy/RvXt3nX0hISGIjIzEpk2bpFfSF2vSpAlGjBihs2/JkiXo168fZsyYgWbNmqFPnz4G1fPzzz9Hu3btEBkZiTfffBMFBQWoWbPmE88rq5xWq0VhYSFcXFwMuj+RqTiGhYgAPPpACwkJQfXq1eHp6YkhQ4bg0qVLOmV++uknvPrqq6hfvz6USiX8/f0xffp03Lt3Tyrz2muvISEhAYButwYAXLhwAQqFAu+99x4SEhKkrpFevXrh0qVLEEJg0aJFqFevHqpXr47+/fvj5s2bOnX4+uuv0bdvX/j5+UGpVKJRo0ZYtGgRNBqNTrnirq+MjAx07NgR1atXR2BgIFavXm3Q9+Phw4dYtGgRGjVqBKVSiYCAALz55pt48OCBVEahUGDDhg0oKCiQ2pmYmFjmNR8PVgDgpZdeAgCcOnXKoHrVqlULW7ZsgZOTk8EvVLt37x527NiBIUOGYNCgQbh37x6+/vrrUuVee+01uLq64ty5c+jTpw+eeuopDB8+HMCjtkZFRWHTpk1o2bIllEolkpOTAQDvvfceOnbsiFq1aqF69eoICQnBl19+qXPtbt26ISgoSG/9mjZtioiICIPaQvZLC4W0PH+FNhmNYWGGhexKXl4ebty4UWp/UVFRqX1vv/025s2bh0GDBmHs2LG4fv06PvroI3Tt2hXHjh2Du7s7AGD79u24e/cuJk2ahFq1auHw4cP46KOP8Oeff2L79u0AgAkTJuDKlStISUnBP//5T71127RpEwoLCzFlyhTcvHkTS5cuxaBBg9CjRw+kpaVh9uzZOHv2LD766CPMnDkT69evl85NTEyEq6sroqOj4erqij179iA2Nhb5+flYtmyZzn1u3bqFPn36YNCgQRg6dCi2bduGSZMmwdnZGf/3f/9X7vdv7Nix2LhxI1555RXMmDEDhw4dQnx8PE6dOoUdO3YAAP75z39izZo1OHz4MD777DMAQMeOHcu97uPUajUAwMvLy+Bz6tevj27dumHv3r3Iz89/4ovcvvnmG9y5cwdDhgyBr68vunfvjk2bNmHYsGGlyj58+BARERHo3Lkz3nvvPdSoUUM6tmfPHmzbtg1RUVHw8vJCQEAAAGDlypV48cUXMXz4cBQWFmLLli149dVXsWvXLvTt2xcAMHLkSIwbNw4nT57UGUP1n//8B2fOnMHcuXMNbj9RlSeI7MCGDRsEgHK3li1bSuUvXLggHB0dxdtvv61znRMnTggnJyed/Xfv3i11v/j4eKFQKMTFixelfZMnTxb6/sllZWUJAKJ27doiNzdX2h8TEyMAiKCgIFFUVCTtHzp0qHB2dhb3798vtw4TJkwQNWrU0CnXrVs3AUC8//770r4HDx6I4OBg4e3tLQoLC0t/8/4rMzNTABBjx47V2T9z5kwBQOzZs0faFxkZKWrWrFnmtZ5kzJgxwtHRUZw5c0ZnPwAxefLkMs+bNm2aACB++eWXJ97jhRdeEJ06dZK+XrNmjXBychLXrl3TKRcZGSkAiDlz5pS6BgDh4OAgfv3111LHHn8mhYWFolWrVqJHjx7SvtzcXOHi4iJmz56tU3bq1KmiZs2a4s6dO09sB9mnvLw8AUC8mjpKDPt5bIW3V1NHCQAiLy/P2k16InYJkV1JSEhASkpKqa1NmzY65b766itotVoMGjQIN27ckDZfX180btwYe/fulcqWHBRaUFCAGzduoGPHjhBC4NixYwbX7dVXX4Wbm5v0dWhoKABgxIgRcHJy0tlfWFiIy5cv663D7du3cePGDXTp0gV3797F77//rnMfJycnTJgwQfra2dkZEyZMwLVr15CRkVFm/ZKSkgCg1KDWGTNmAAC+++47g9tans2bN2PdunWYMWMGGjdubNS5rq6uAB59D8rz119/Yffu3Rg6dKi07+WXX4ZCocC2bdv0njNp0iS9+7t164YWLVqU2l/ymdy6dQt5eXno0qULjh49Ku13c3ND//798cUXX0CIR0uOajQabN26FQMGDDBoPA3ZN5O6g0x803NlY5cQ2ZUOHTqgffv2pfZ7eHjodBX98ccfEEKU+YFZrVo16f+zs7MRGxuLb775Brdu3dIpl5eXZ3Dd6tevr/N1cfDi7++vd3/Je/3666+YO3cu9uzZg/z8/HLr4OfnV+qDsEmTJgAejad55pln9Nbv4sWLcHBwwNNPP62z39fXF+7u7rh48WK57TPETz/9hDFjxiAiIsLgsSgl3blzBwDw1FNPlVtu69atKCoqQtu2bXH27Flpf2hoKDZt2oTJkyfrlHdyckK9evX0XiswMFDv/l27dmHx4sXIzMwsNcanpFGjRmHr1q346aef0LVrV/z444/IycnByJEjy20Dkb1hwEKkh1arldbmcHR0LHW8+C95jUaD5557Djdv3sTs2bPRrFkz1KxZE5cvX8Zrr70GrVZr8D313ae8/cV/kefm5qJbt25QqVRYuHAhGjVqBBcXFxw9ehSzZ882qg6GePwD11x++eUXvPjii2jVqhW+/PJLnaySoU6ePAlHR8cyg4himzZtAgB06tRJ7/Hz58+jYcOG0tdKpRIODvoT0o9PuwYeBV4vvvgiunbtio8//hh16tRBtWrVsGHDBmzevFmnbEREBHx8fPD555+ja9eu+Pzzz+Hr64vw8PBy20AE2NcsIQYsRHo0atQIQggEBgZK2Qd9Tpw4gTNnzmDjxo0YNWqUtD8lJaVUWUt90KelpeGvv/7CV199ha5du0r7s7Ky9Ja/cuVKqWm5Z86cAQBpwKg+DRo0gFarxR9//IHmzZtL+3NycpCbm4sGDRpUuA3nzp1D79694e3tjaSkJCkgNEZ2djb27duHsLCwcjMsWVlZOHjwIKKiotCtWzedY1qtFiNHjsTmzZtNGvD6r3/9Cy4uLti9ezeUSqW0f8OGDaXKOjo6YtiwYUhMTMS7776LnTt3Yty4cWUGqkQlmdqtI6cuIfmEVkSVaODAgXB0dMSCBQukTEYxIQT++usvAP/LfpQsI4TAypUrS12zOEDQt4KrKfTVobCwEB9//LHe8g8fPsSnn36qU/bTTz9F7dq1ERISUuZ9itc2WbFihc7+5cuXA4A088VYarUavXr1goODA3bv3o3atWsbfY2bN29i6NCh0Gg0eOutt8otW5xdmTVrFl555RWdbdCgQejWrZtUpqIcHR2hUCh0ppVfuHABO3fu1Ft+5MiRuHXrFiZMmIA7d+6UWmeGiJhhIdKrUaNGWLx4MWJiYnDhwgUMGDAATz31FLKysrBjxw6MHz8eM2fORLNmzdCoUSPMnDkTly9fhkqlwr/+9a9SY1kASMHA1KlTERERAUdHRwwZMsTkunbs2BEeHh6IjIzE1KlToVAo8M9//rNUoFXMz88P7777Li5cuIAmTZpg69atyMzMxJo1a3TG5jwuKCgIkZGRWLNmjdQNdfjwYWzcuBEDBgzAs88+W6H69+7dG+fPn8esWbNw4MABHDhwQDrm4+OD5557Tqf8mTNn8Pnnn0MIgfz8fPzyyy/Yvn077ty5g+XLl6N3797l3m/Tpk0IDg4uNTao2IsvvogpU6bg6NGjaNeuXYXa1LdvX6kuw4YNw7Vr15CQkICnn34ax48fL1W+bdu2aNWqFbZv347mzZtX+L5kf0x9HxDXYSGqAubMmYMmTZrggw8+wIIFCwA8GgDbq1cvvPjiiwAeDb799ttvMXXqVMTHx8PFxQUvvfQSoqKiSi0INnDgQEyZMgVbtmyRPnDNEbDUqlULu3btwowZMzB37lx4eHhgxIgR6Nmzp96Fxzw8PLBx40ZMmTIFa9euhY+PD1atWoVx48Y98V6fffYZGjZsiMTEROzYsQO+vr6IiYlBXFxchev/yy+/AACWLl1a6li3bt1KBSzFM7scHBygUqkQGBiIyMhIjB8/Xu9snZKOHj2K33//HfPmzSuzTL9+/TBlyhRpFdyK6NGjB9atW4clS5bg9ddfR2BgoBQk6gtYgEeDb2fNmsXBtmQUe+oSUoiy/gwjoiqne/fuuHHjBk6ePGntqtBjVq5cienTp+PChQulZowRPS4/Px9ubm54PnkcqtV88iswylJUUIjve69FXl7eExdbtDaOYSEisjIhBNatW4du3boxWCEqA7uEiIispKCgAN988w327t2LEydO6H2XEVF57KlLiAELEZGVXL9+HcOGDYO7uzvefPNNaWwUkaHsKWCxqy6hhIQEBAQEwMXFBaGhoTh8+LC1q0RUqdLS0jh+xYYEBARACIFbt25VaGVfIntiNwHL1q1bER0djbi4OBw9ehRBQUGIiIjAtWvXrF01IiKiChH439TmimxymnVjNwHL8uXLMW7cOIwePRotWrTA6tWrUaNGDaxfv97aVSMiIqoQvvywiiksLERGRgZiYmKkfQ4ODggPD0d6enqp8g8ePNB5WZlWq8XNmzdRq1Ytiy2vTkREVYMQArdv34afn1+Z76Ai49lFwHLjxg1oNBr4+Pjo7Pfx8cHvv/9eqnx8fLy0UBgREVFFXLp0qcy3fJuLPQ26tYuAxVgxMTGIjo6Wvs7Ly0P9+vXRGX3ghLKXLiciInqIIhxAUrkv4TQXBixVjJeXFxwdHZGTk6OzPycnB76+vqXKK5VKnTesFnNCNTgpGLAQEVE5/juSlUMIzMsuOtecnZ0REhKC1NRUaZ9Wq0VqairCwsKsWDMiIqKK46DbKig6OhqRkZFo3749OnTogBUrVqCgoACjR4+2dtWIiIgqRAgFhAlBhynnVja7CVgGDx6M69evIzY2Fmq1GsHBwUhOTi41EJeIiEguitdTMeV8ubCbgAUAoqKiEBUVZe1qEBERkZHsKmAhIiKqSjhLiIiIiGyePY1hsYtZQkRERCRvzLAQERHJFLuEiIiIyOaxS4iIiIjIhjDDQkREJFPCxC4hOWVYGLAQERHJlAAghGnnywW7hIiIiMjmMcNCREQkU1oooODS/ERERGTL7GmWEAMWIiIimdIKBRR2sg4Lx7AQERGRzWOGhYiISKaEMHGWkIymCTFgISIikil7GsPCLiEiIiKyecywEBERyZQ9ZVgYsBAREckUZwkRERER2RBmWIiIiGSKs4SIiGzM7iuZOl9H+AVbpR5EtuRRwGLKGBYzVsbC2CVERDbv8WCFiOwPMyxEZHMYoBAZhrOEiIisgIEKkXHEfzdTzpcLdgkRkU0wNlhhcEP0vwyLKZtcMGAhIqtj8EFET8IuISKyKgYrRCawoz4hZliIyGoYrBCZyNTuoAp2CSUkJCAgIAAuLi4IDQ3F4cOHyy2fm5uLyZMno06dOlAqlWjSpAmSkpKMuiczLERkFQxWiORp69atiI6OxurVqxEaGooVK1YgIiICp0+fhre3d6nyhYWFeO655+Dt7Y0vv/wSdevWxcWLF+Hu7m7UfRmwEJFslQx6uJAc2SNrrHS7fPlyjBs3DqNHjwYArF69Gt999x3Wr1+POXPmlCq/fv163Lx5EwcPHkS1atUAAAEBAUbfl11CRFTpjMmuRPgFSxsR6TLXLKH8/Hyd7cGDB3rvV1hYiIyMDISHh0v7HBwcEB4ejvT0dL3nfPPNNwgLC8PkyZPh4+ODVq1a4Z133oFGozGqrQxYiKhSGRusWOK6RKTL398fbm5u0hYfH6+33I0bN6DRaODj46Oz38fHB2q1Wu8558+fx5dffgmNRoOkpCTMmzcP77//PhYvXmxUHdklRESVxpSgggEJkR4mDJyVzgdw6dIlqFQqabdSqTS1ZhKtVgtvb2+sWbMGjo6OCAkJweXLl7Fs2TLExcUZfB0GLERUKYwNOIqzKwxUiMpmrjEsKpVKJ2Api5eXFxwdHZGTk6OzPycnB76+vnrPqVOnDqpVqwZHR0dpX/PmzaFWq1FYWAhnZ2eD6souISKyqN1XMis0ZqX4XCIqhzDDZgRnZ2eEhIQgNTVV2qfVapGamoqwsDC953Tq1Alnz56FVquV9p05cwZ16tQxOFgBGLAQkYUYG6gAnOlDJAfR0dFYu3YtNm7ciFOnTmHSpEkoKCiQZg2NGjUKMTExUvlJkybh5s2bmDZtGs6cOYPvvvsO77zzDiZPnmzUfdklRERmx8wIUeWwxtuaBw8ejOvXryM2NhZqtRrBwcFITk6WBuJmZ2fDweF/+RB/f3/s3r0b06dPR5s2bVC3bl1MmzYNs2fPNuq+DFiIyCYwu0JUQVZYXj8qKgpRUVF6j6WlpZXaFxYWhp9//tmke7JLiIhsArMyRFQeZliIyGbsvpKpk2l5UtaFQQ7ZO2t0CVkLAxYiMrsIv+BSwYS+ffrO04eBCVEZ+LZmIiJdFZn1U6w4ECkvY1LRY0RkH5hhIaInKg5UjAkcGGQQVQbFfzdTzpcHZliIyGAVzbKUPM/Y9wOxO4ioHJW8cJw12XTAMn/+fCgUCp2tWbNm0vH79+9j8uTJqFWrFlxdXfHyyy+XWi44Ozsbffv2RY0aNeDt7Y033ngDDx8+rOymEFUZxmZODAk4OLiWiJ7EpgMWAGjZsiWuXr0qbQcOHJCOTZ8+Hd9++y22b9+Offv24cqVKxg4cKB0XKPRoG/fvigsLMTBgwexceNGJCYmIjY21hpNIaoSKrLUfsn/lpwJVHIZfiKqADvKsNj8GBYnJye9L1TKy8vDunXrsHnzZvTo0QMAsGHDBjRv3hw///wznnnmGfzwww/47bff8OOPP8LHxwfBwcFYtGgRZs+ejfnz5xv1DgMie1MyKDHnu33KGoBbssuIGRUiA5npbc1yYPMByx9//AE/Pz+4uLggLCwM8fHxqF+/PjIyMlBUVITw8HCpbLNmzVC/fn2kp6fjmWeeQXp6Olq3bi0tFwwAERERmDRpEn799Ve0bdtW7z0fPHiABw8eSF/n5+dbroE2zNQPDf7lLF9lPfuSwcTja6ZU9JoVLUdE5ntbsxzYdMASGhqKxMRENG3aFFevXsWCBQvQpUsXnDx5Emq1Gs7OznB3d9c5x8fHB2q1GgCgVqt1gpXi48XHyhIfH48FCxaYtzH0RAyQbJu+51NW0MKgg4jMzaYDlueff176/zZt2iA0NBQNGjTAtm3bUL16dYvdNyYmBtHR0dLX+fn58Pf3t9j9iGyZIQNiS5ZhsEJUiexo4TijA5bk5GS4urqic+fOAICEhASsXbsWLVq0QEJCAjw8PMxeyWLu7u5o0qQJzp49i+eeew6FhYXIzc3VybLk5ORIY158fX1x+PBhnWsUzyLSNy6mmFKphFKpNH8DyCpM+QC116yNvnYbMraEwQpRJeMYlrK98cYbePfddwEAJ06cwIwZMxAdHY29e/ciOjoaGzZsMHsli925cwfnzp3DyJEjERISgmrVqiE1NRUvv/wyAOD06dPIzs5GWFgYgEdvh3z77bdx7do1eHt7AwBSUlKgUqnQokULi9WTHinvw6uyAgF+gJpPeeuo2Mr3Wd9AYSKqGowOWLKysqQP+3/961944YUX8M477+Do0aPo06ePWSs3c+ZM9OvXDw0aNMCVK1cQFxcHR0dHDB06FG5ubhgzZgyio6Ph6ekJlUqFKVOmICwsDM888wwAoFevXmjRogVGjhyJpUuXQq1WY+7cuZg8eTIzKAaw99ka/MDT9Xi3jxx+PsxVP/4skK1SiEebKefLhdHrsDg7O+Pu3bsAgB9//BG9evUCAHh6epp9Ns2ff/6JoUOHomnTphg0aBBq1aqFn3/+GbVr1wYAfPDBB3jhhRfw8ssvo2vXrvD19cVXX30lne/o6Ihdu3bB0dERYWFhGDFiBEaNGoWFCxeatZ5VlbGzQKoKc07hrWqK12Cxp2CFyKZxHZayde7cGdHR0ejUqRMOHz6MrVu3AgDOnDmDevXqmbVyW7ZsKfe4i4sLEhISkJCQUGaZBg0aICkpyaz1sidy+XAyh+J22kNbTcXvERFVNqMDllWrVuHvf/87vvzyS3zyySeoW7cuAOD7779H7969zV5Bsh57+wC3l3aaQo7ZJ1PqbEiGkdPxyao46LZs9evXx65du0rt/+CDD8xSIbIPFXkRHtkOW8u66ZtWbcpUa/5ckmxwWrOu/Px8qFQq6f/LU1yOSO74oWU55ly3xZwvTixrBhR/Foisz6CAxcPDA1evXoW3tzfc3d2hUJROIQkhoFAooNFozF5JosrCDybz0xecPP4CxIoGLWWtF/Ok+5eFwYl1PP5cynsGxpS1C8yw6NqzZw88PT2l/9cXsFDVY0sp/8pg97/4SjBnAFHePfS9ydkS93r8HEvfh/R70juqGKhUAAMWXd26dZP+v3v37paqC9kYWxunQJXH3M+++MPo8YDh8fEm5hjUa+riccyyVJ6S32dDvud8Lnpw0G3Z5s+fj9jYWDg46C7hkpeXh4kTJ+KLL74wW+XIuuwlWOEvQdOYI9NhyCBsfcGMpV4VwKDF8hhMkrGMXjhu3bp16Ny5M86fPy/tS0tLQ+vWrXHu3DmzVo6sq6r/Yij5Fz9VjKnfv5LPoLy/tvUds5eAuqrhvzvzKl7p1pRNLozOsBw/fhwTJkxAcHAw3n//fZw5cwYrV67EG2+8gQULFliijmRFlfnemMr8JcZfmOUz9Bkb+hev3L7fcquvnJiSJeFz0YNjWMrm4eGBbdu24c0338SECRPg5OSE77//Hj179rRE/YjMir/wDGPoGJaKfj8fH2dS0bdDWwq7HizLmO8vM2lUzOiABQA++ugjrFy5EkOHDkVGRgamTp2KzZs3IygoyNz1IzIrfhAZTt/LDsti6IeKvu6fJ5XXd+3Hu4We9HVF8M3P1sVAhR5ndMDSu3dvHDlyBBs3bsQrr7yCe/fuITo6Gs888wwWLFiAWbNmWaKeRBXCDxrLqcgHSkUCRkMG4hpS1lZxivUjT/o+VOW2m0IBE9/WbLaaWJ7RAYtGo8Hx48fh5+cHAKhevTo++eQTvPDCCxg7diwDFjvA6c725fGZPKbgh459K29MXFlZMqJiRgcsKSkpevf37dsXJ06cMLlCJA8MWqo+SzzfyuySq4qZi6r0osWyutxsqY6ywHVYKsbLy8uclyMbx6Cl6rLkczV0xVJLrWzKD8TyVVZQxN8fZsJZQmXTaDT44IMPsG3bNmRnZ6OwsFDn+M2bN81WOZIPro1BFWXo25X5syUPxnTpMHgkYxgdsCxYsACfffYZZsyYgblz5+Ktt97ChQsXsHPnTsTGxlqijmTDiv9K4uwbMqfHf5ZsOVgx5OfeVupvK/UgM2KGpWybNm3C2rVr0bdvX8yfPx9Dhw5Fo0aN0KZNG/z888+YOnWqJepJNqxkdsXS63eQZVWVDzR2N5C9MHW12iq90q1arUbr1q0BAK6ursjLywMAvPDCC5g3b555a0eyUXImCbuH5MfWn1VF37Js6+2qivjHSCWzowyL0e8SqlevHq5evQoAaNSoEX744QcAwH/+8x8olUrz1o5ko3i10pIfEvzFZfuKu/OqqqqwTgsRPWJ0huWll15CamoqQkNDMWXKFIwYMQLr1q1DdnY2pk+fbok6kozxr1wyJ1PeDG1N9vDvwJiVkcmM7CjDYnTAsmTJEun/Bw8ejPr16yM9PR2NGzdGv379zFo5kif+VSsPlvwA5TMvraoGLfoGSPP5Vx6OYTFCWFgYwsLCzFEXIqokVfGDUw4sHbRUxvixJwUjDFbIUkwKWFQqFTIzM9GwYUNz1YeIZIgfUoYz55RtS33f2b0jI1zptrQrV65I7w8qJoSMcklEZDB+QNk2Q7McFQmG9C3gx6DFhtnRGBaDZwm1bNkSmzdvtmRdiKiS8MNHviz97B5/x0/xZsz57HIkSzA4w/L2229jwoQJ2LFjBz799FN4enpixIgRUKlUlqwfEVkIgxZ5qegMqYoED+bIqDArUznsadCtwRmWv//97zh+/Dj++usvtGjRAt9++y0++eQTvvCQiMgEhnTvmPLBX5EsCVC13gxdpQkzbDJh1MJxgYGB2LNnD+bOnYuBAweiTZs2aNeunc5GRETGsdUPd1PGwLBbiMzN6FlCFy9exFdffQUPDw/0798fTk4mz4wmIqJK8PhK1JYKKmw1AKuSTOwSklOGxahoY+3atZgxYwbCw8Px66+/onbt2paqFxGRXbHGwnKWzIY8/l4xBjEWYkezhAwOWHr37o3Dhw9j1apVGDVqlCXrRERklyrrQ72s1agfnyFk6j2KAxUGKxbEgKU0jUaD48ePo169epasDxERWVh5GY+KBBdlXe/xQIiBC5nC4IAlJSXFkvUgIqJKUF7XU0UDCn3ncdBt5eC0ZiIiqrKKgxZzBBXlBT8lAxlmV8hUDFiIiKq44uBEX3BR0cCl5Dnlnc8xLGQuDFiIiKq4kkGDqeNJ9AU4DEisiAvHERFRVVMyaDE0cCn5AsSyMinGZGg4tsW8isewmLLJBVd9IyKyI48PujVkjZQnBRn63vBc1nGiimLAQkRkZ4wJWgx515Ep5ckMZJQlMQW7hIiI7NDjgQO7amSKY1iIiKiqY9BCcsIuISIiO8a3K8ubPS0cx4CFiIgs8j4hqgR29C4hq3YJ7d+/H/369YOfnx8UCgV27typc1wIgdjYWNSpUwfVq1dHeHg4/vjjD50yN2/exPDhw6FSqeDu7o4xY8bgzp07OmWOHz+OLl26wMXFBf7+/li6dKmlm0ZEJEtc6E1e7Glas1UDloKCAgQFBSEhIUHv8aVLl+LDDz/E6tWrcejQIdSsWRMRERG4f/++VGb48OH49ddfkZKSgl27dmH//v0YP368dDw/Px+9evVCgwYNkJGRgWXLlmH+/PlYs2aNxdtHRCRXDFrI1lg1YHn++eexePFivPTSS6WOCSGwYsUKzJ07F/3790ebNm3wj3/8A1euXJEyMadOnUJycjI+++wzhIaGonPnzvjoo4+wZcsWXLlyBQCwadMmFBYWYv369WjZsiWGDBmCqVOnYvny5ZXZVCIiIvOz0iyhhIQEBAQEwMXFBaGhoTh8+LBB523ZsgUKhQIDBgww+p42O0soKysLarUa4eHh0j43NzeEhoYiPT0dAJCeng53d3e0b99eKhMeHg4HBwccOnRIKtO1a1c4OztLZSIiInD69GncunVL770fPHiA/Px8nY2IiMjmWCFg2bp1K6KjoxEXF4ejR48iKCgIERERuHbtWrnnXbhwATNnzkSXLl2MvylsOGBRq9UAAB8fH539Pj4+0jG1Wg1vb2+d405OTvD09NQpo+8aJe/xuPj4eLi5uUmbv7+/6Q0iIiKqApYvX45x48Zh9OjRaNGiBVavXo0aNWpg/fr1ZZ6j0WgwfPhwLFiwAA0bNqzQfW02YLGmmJgY5OXlSdulS5esXSUiIqJSzDXo9vFehQcPHui9X2FhITIyMnR6PxwcHBAeHi71fuizcOFCeHt7Y8yYMRVuq80GLL6+vgCAnJwcnf05OTnSMV9f31IpqIcPH+LmzZs6ZfRdo+Q9HqdUKqFSqXQ2IiIim2OmLiF/f3+dnoX4+Hi9t7tx4wY0Gk25vR+PO3DgANatW4e1a9ea1FSbDVgCAwPh6+uL1NRUaV9+fj4OHTqEsLAwAEBYWBhyc3ORkZEhldmzZw+0Wi1CQ0OlMvv370dRUZFUJiUlBU2bNoWHh0cltYaIiMh2Xbp0SadnISYmxizXvX37NkaOHIm1a9fCy8vLpGtZdeG4O3fu4OzZs9LXWVlZyMzMhKenJ+rXr4/XX38dixcvRuPGjREYGIh58+bBz89PGl3cvHlz9O7dG+PGjcPq1atRVFSEqKgoDBkyBH5+fgCAYcOGYcGCBRgzZgxmz56NkydPYuXKlfjggw+s0WQiIiLzMdPCcYb2Jnh5ecHR0bHc3o+Szp07hwsXLqBfv37SPq1WC+DRmNPTp0+jUaNGBlXVqgHLkSNH8Oyzz0pfR0dHAwAiIyORmJiIWbNmoaCgAOPHj0dubi46d+6M5ORkuLi4SOds2rQJUVFR6NmzJxwcHPDyyy/jww8/lI67ubnhhx9+wOTJkxESEgIvLy/ExsbqrNVCREQkR5W9NL+zszNCQkKQmpoqJQ+0Wi1SU1MRFRVVqnyzZs1w4sQJnX1z587F7du3sXLlSqMmtVg1YOnevTuEKPu7pVAosHDhQixcuLDMMp6enti8eXO592nTpg1++umnCteTiIiIHomOjkZkZCTat2+PDh06YMWKFSgoKMDo0aMBAKNGjULdunURHx8PFxcXtGrVSud8d3d3ACi1/0n4LiGi/zLl5W9cFZSIrMIK7xIaPHgwrl+/jtjYWKjVagQHByM5OVkaiJudnQ0HB/MPkWXAQkREJFPWeltzVFSU3i4gAEhLSyv33MTExArdkwELERGRXNnR25oZsBDBtO4gQ89ntxERUcUxYCEiIpIrZliIiIjI1in+u5lyvlwwYCGyMHYFERGZjgEL2T1Tx68QEVkNu4SI7EeEX7BFghZmVojI0qw1rdkabPblh0SVhcEKEZHtY4aFyATFgUnJoIfBChFVGnYJEdkHc6y/EuEXzCCFyA4V//u3OhkFHaZglxCRiThol8g+2USwYkcYsJDdMlegwV9aRPZr95VM6XeJNf54KR50a8omF+wSIrtVkdlBDE6ISB+rZVo5hoWo6mNXDhGZkzX+oOG0ZiKSFP8SYnaFiAD9f+zw94PlMcNCZAD+MiKikmxmhiC7hIiqPkutcEtEVZMtrrdkT11CDFiIymErv5SIyHoe/8OGvxesgwEL2SVDMiv8pURENh+ssEuIyL7Z3C8lIqp0Nh+sAAxYiKo6m/zFQ0Q2hb8nbAsDFiIiIpnioFsiIiKyfXbUJcSF44iIiMjmMcNCREQkUwohoBAVT5OYcm5lY8BCREQkV3bUJcSAhYiISKbsadAtx7AQERGRzWOGhYiISK7YJURERES2zp66hBiwGED8dxT1QxTJKholIqLK9xBFAP732UHmwYDFAH/99RcA4ACSrFwTIiKSi9u3b8PNzc2yN2GXEJXk6ekJAMjOzrb8D58V5Ofnw9/fH5cuXYJKpbJ2dcyKbZMntk2e2LZHhBC4ffs2/Pz8LF4vdgmRDgeHR5Op3Nzcqtw/wpJUKlWVbR/bJk9smzyxbaiSf9xaGwMWIiIiuWKXEBEREcmBnLp1TMGF4wygVCoRFxcHpVJp7apYRFVuH9smT2ybPLFtZEkKwXlXREREspKfnw83NzeEvLoYTtVcKnydh0X3kbF9LvLy8mx+3BG7hIiIiGSKs4SIiIjI9tnRoFuOYSEiIiKbxwwLERGRTCm0jzZTzpcLZlgMkJCQgICAALi4uCA0NBSHDx+2dpWeaP78+VAoFDpbs2bNpOP379/H5MmTUatWLbi6uuLll19GTk6OzjWys7PRt29f1KhRA97e3njjjTfw8OHDym4K9u/fj379+sHPzw8KhQI7d+7UOS6EQGxsLOrUqYPq1asjPDwcf/zxh06ZmzdvYvjw4VCpVHB3d8eYMWNw584dnTLHjx9Hly5d4OLiAn9/fyxdutTSTXti21577bVSz7F37946ZWyxbfHx8fjb3/6Gp556Ct7e3hgwYABOnz6tU8ZcP4NpaWlo164dlEolnn76aSQmJlq0bYBh7evevXupZzdx4kSdMrbYvk8++QRt2rSRFkgLCwvD999/Lx2X83N7Uttk+cyEGTaZYMDyBFu3bkV0dDTi4uJw9OhRBAUFISIiAteuXbN21Z6oZcuWuHr1qrQdOHBAOjZ9+nR8++232L59O/bt24crV65g4MCB0nGNRoO+ffuisLAQBw8exMaNG5GYmIjY2NhKb0dBQQGCgoKQkJCg9/jSpUvx4YcfYvXq1Th06BBq1qyJiIgI3L9/XyozfPhw/Prrr0hJScGuXbuwf/9+jB8/Xjqen5+PXr16oUGDBsjIyMCyZcswf/58rFmzxqptA4DevXvrPMcvvvhC57gttm3fvn2YPHkyfv75Z6SkpKCoqAi9evVCQUGBVMYcP4NZWVno27cvnn32WWRmZuL111/H2LFjsXv3bou1zdD2AcC4ceN0nl3JQNFW21evXj0sWbIEGRkZOHLkCHr06IH+/fvj119/BSDv5/aktgHyfGZ2Q1C5OnToICZPnix9rdFohJ+fn4iPj7dirZ4sLi5OBAUF6T2Wm5srqlWrJrZv3y7tO3XqlAAg0tPThRBCJCUlCQcHB6FWq6Uyn3zyiVCpVOLBgwcWrXt5AIgdO3ZIX2u1WuHr6yuWLVsm7cvNzRVKpVJ88cUXQgghfvvtNwFA/Oc//5HKfP/990KhUIjLly8LIYT4+OOPhYeHh07bZs+eLZo2bWrhFv3P420TQojIyEjRv3//Ms+RS9uuXbsmAIh9+/YJIcz3Mzhr1izRsmVLnXsNHjxYREREWLpJOh5vnxBCdOvWTUybNq3Mc+TUPg8PD/HZZ59VuecmxP/aJoS8nlleXp4AIDr0Xyw6vvJehbcO/RcLACIvL8+s9bMEZljKUVhYiIyMDISHh0v7HBwcEB4ejvT0dCvWzDB//PEH/Pz80LBhQwwfPhzZ2dkAgIyMDBQVFem0q1mzZqhfv77UrvT0dLRu3Ro+Pj5SmYiICOTn5+v8NWJtWVlZUKvVOm1xc3NDaGioTlvc3d3Rvn17qUx4eDgcHBxw6NAhqUzXrl3h7OwslYmIiMDp06dx69atSmqNfmlpafD29kbTpk0xadIk6e3hgHzalpeXB+B/LxI1189genq6zjWKy1T2v8/H21ds06ZN8PLyQqtWrRATE4O7d+9Kx+TQPo1Ggy1btqCgoABhYWFV6rk93rZisntmQpi+yQQH3Zbjxo0b0Gg0Oj+cAODj44Pff//dSrUyTGhoKBITE9G0aVNcvXoVCxYsQJcuXXDy5Emo1Wo4OzvD3d1d5xwfHx+o1WoAgFqt1tvu4mO2orgu+upasi3e3t46x52cnODp6alTJjAwsNQ1io95eHhYpP5P0rt3bwwcOBCBgYE4d+4c3nzzTTz//PNIT0+Ho6OjLNqm1Wrx+uuvo1OnTmjVqpV0X3P8DJZVJj8/H/fu3UP16tUt0SQd+toHAMOGDUODBg3g5+eH48ePY/bs2Th9+jS++uqrcutefKy8MpZu34kTJxAWFob79+/D1dUVO3bsQIsWLZCZmSn751ZW2wB5PzN7wIClinr++eel/2/Tpg1CQ0PRoEEDbNu2jf9gZGTIkCHS/7du3Rpt2rRBo0aNkJaWhp49e1qxZoabPHkyTp48qTOGqiopq30lxxG1bt0aderUQc+ePXHu3Dk0atSosqtplKZNmyIzMxN5eXn48ssvERkZiX379lm7WmZRVttatGghy2dmTwvHsUuoHF5eXnB0dCw1Aj4nJwe+vr5WqlXFuLu7o0mTJjh79ix8fX1RWFiI3NxcnTIl2+Xr66u33cXHbEVxXcp7Rr6+vqUGST98+BA3b96UXXsbNmwILy8vnD17FoDtty0qKgq7du3C3r17Ua9ePWm/uX4GyyqjUqkqJTAvq336hIaGAoDOs7PV9jk7O+Ppp59GSEgI4uPjERQUhJUrV1aJ51ZW2/SRxTPjLCECHv1gh4SEIDU1Vdqn1WqRmpqq0+cpB3fu3MG5c+dQp04dhISEoFq1ajrtOn36NLKzs6V2hYWF4cSJEzofhikpKVCpVFL61BYEBgbC19dXpy35+fk4dOiQTltyc3ORkZEhldmzZw+0Wq30CyksLAz79+9HUVGRVCYlJQVNmza1WneQPn/++Sf++usv1KlTB4Dttk0IgaioKOzYsQN79uwp1SVlrp/BsLAwnWsUl7H0v88ntU+fzMxMANB5drbavsdptVo8ePBA9s9Nn+K26SPnZ1YlWXvUr63bsmWLUCqVIjExUfz2229i/Pjxwt3dXWeUuC2aMWOGSEtLE1lZWeLf//63CA8PF15eXuLatWtCCCEmTpwo6tevL/bs2SOOHDkiwsLCRFhYmHT+w4cPRatWrUSvXr1EZmamSE5OFrVr1xYxMTGV3pbbt2+LY8eOiWPHjgkAYvny5eLYsWPi4sWLQgghlixZItzd3cXXX38tjh8/Lvr37y8CAwPFvXv3pGv07t1btG3bVhw6dEgcOHBANG7cWAwdOlQ6npubK3x8fMTIkSPFyZMnxZYtW0SNGjXEp59+arW23b59W8ycOVOkp6eLrKws8eOPP4p27dqJxo0bi/v379t02yZNmiTc3NxEWlqauHr1qrTdvXtXKmOOn8Hz58+LGjVqiDfeeEOcOnVKJCQkCEdHR5GcnGyxthnSvrNnz4qFCxeKI0eOiKysLPH111+Lhg0biq5du9p8++bMmSP27dsnsrKyxPHjx8WcOXOEQqEQP/zwgxBC3s+tvLbJ7ZkVzxJ6pu8i0XnAsgpvz/RdJJtZQgxYDPDRRx+J+vXrC2dnZ9GhQwfx888/W7tKTzR48GBRp04d4ezsLOrWrSsGDx4szp49Kx2/d++e+Pvf/y48PDxEjRo1xEsvvSSuXr2qc40LFy6I559/XlSvXl14eXmJGTNmiKKiospuiti7d6/eRGZkZKQQ4tHU5nnz5gkfHx+hVCpFz549xenTp3Wu8ddff4mhQ4cKV1dXoVKpxOjRo8Xt27d1yvzyyy+ic+fOQqlUirp164olS5ZYtW13794VvXr1ErVr1xbVqlUTDRo0EOPGjSsVLNti2/S1CYDYsGGDVMZcP4N79+4VwcHBwtnZWTRs2FDnHtZqX3Z2tujatavw9PQUSqVSPP300+KNN94o9aFgi+37v//7P9GgQQPh7OwsateuLXr27CkFK0LI+7mV1za5PTMpYOmzUHTuv7TC2zN9FsomYFEIIaM5TURERIT8/Hy4ubkh7PmFcKrmUuHrPCy6j/TvY5GXlweVSmXGGpofx7AQERGRzeO0ZiIiIrkydaaPjPpYGLAQERHJFNdhISIiIrIhzLAQERHJlVY82kw5XyYYsBAREcmVHY1hYZcQERER2TxmWIiIiGRKARMH3ZqtJpbHDAsRWVxaWhoUCkWpl+YRkYmEMH2TCQYsRHZEo9GgY8eOGDhwoM7+vLw8+Pv746233rLIfTt27IirV6/Czc3NItcnoqqPAQuRHXF0dERiYiKSk5OxadMmaf+UKVPg6emJuLg4i9zX2dkZvr6+UCjklIAmsn3F67CYslVEQkICAgIC4OLigtDQUBw+fLjMsmvXrkWXLl3g4eEBDw8PhIeHl1u+LAxYiOxMkyZNsGTJEkyZMgVXr17F119/jS1btuAf//gHnJ2d9Z4ze/ZsNGnSBDVq1EDDhg0xb948FBUVAQCEEAgPD0dERASKX0128+ZN1KtXD7GxsQBKdwldvHgR/fr1g4eHB2rWrImWLVsiKSnJ8o0nqmrKfBWnEZuRtm7diujoaMTFxeHo0aMICgpCREQErl27prd8Wloahg4dir179yI9PR3+/v7o1asXLl++bNR9+fJDIjskhECPHj3g6OiIEydOYMqUKZg7d26Z5RcvXowePXrAz88PJ06cwLhx4xAdHY1Zs2YBAC5fvozWrVsjLi4O06ZNw6BBg3Dx4kX8+9//hpOTE9LS0vDss8/i1q1bcHd3xwsvvIDCwkK8//77qFmzJn777TeoVCp07dq1sr4FRLJW/PLDLt3j4ORkwssPH97HT2kLjHr5YWhoKP72t79h1apVAACtVgt/f39MmTIFc+bMeeL5Go0GHh4eWLVqFUaNGmVwXTlLiMgOKRQKfPLJJ2jevDlat279xF8yJYOZgIAAzJw5E1u2bJEClrp16+LTTz/FqFGjoFarkZSUhGPHjsHJSf+vmOzsbLz88sto3bo1AKBhw4ZmahkRVUR+fr7O10qlEkqlslS5wsJCZGRkICYmRtrn4OCA8PBwpKenG3Svu3fvoqioCJ6enkbVkV1CRHZq/fr1qFGjBrKysvDnn38CACZOnAhXV1dpK7Z161Z06tQJvr6+cHV1xdy5c5Gdna1zvVdffRUvvfQSlixZgvfeew+NGzcu895Tp07F4sWL0alTJ8TFxeH48eOWaSRRVac1wwbA398fbm5u0hYfH6/3djdu3IBGo4GPj4/Ofh8fH6jVaoOqPHv2bPj5+SE8PNyopjJgIbJDBw8exAcffIBdu3ahQ4cOGDNmDIQQWLhwITIzM6UNANLT0zF8+HD06dMHu3btwrFjx/DWW2+hsLBQ55p3795FRkYGHB0d8ccff5R7/7Fjx+L8+fMYOXIkTpw4gfbt2+Ojjz6yVHOJqiyFECZvAHDp0iXk5eVJW8kMijktWbIEW7ZswY4dO+DiYlxXFruEiOzM3bt38dprr2HSpEl49tlnERgYiNatW2P16tWYNGkSvL29dcofPHgQDRo00JnyfPHixVLXnTFjBhwcHPD999+jT58+6Nu3L3r06FFmPfz9/TFx4kRMnDgRMTExWLt2LaZMmWK+hhKRwVQqlUFjWLy8vODo6IicnByd/Tk5OfD19S333Pfeew9LlizBjz/+iDZt2hhdR2ZYiOxMTEwMhBBYsmQJgEdjUt577z3MmjULFy5cKFW+cePGyM7OxpYtW3Du3Dl8+OGH2LFjh06Z7777DuvXr8emTZvw3HPP4Y033kBkZCRu3bqltw6vv/46du/ejaysLBw9ehR79+5F8+bNzd5WoiqvkmcJOTs7IyQkBKmpqdI+rVaL1NRUhIWFlXne0qVLsWjRIiQnJ6N9+/bG3fS/GLAQ2ZF9+/YhISEBGzZsQI0aNaT9EyZMQMeOHaWuoZJefPFFTJ8+HVFRUQgODsbBgwcxb9486fj169cxZswYzJ8/H+3atQMALFiwAD4+Ppg4caLeemg0GkyePBnNmzdH79690aRJE3z88ccWaDFRFWeFlW6jo6Oxdu1abNy4EadOncKkSZNQUFCA0aNHAwBGjRql06X07rvvYt68eVi/fj0CAgKgVquhVqtx584do+7Lac1EREQyUzytuWuneSZPa97/70VGTWsGgFWrVmHZsmVQq9UIDg7Ghx9+iNDQUABA9+7dERAQgMTERACPsrj6upHj4uIwf/58g+/JgIWIiEhmigOWbh1ND1j2HTQ+YLEGDrolIiKSK1NfYCijnAXHsBAREZHNY4aFiIhIphTaR5sp58sFAxYiIiK5sqMuIQYsREREclXBNy7rnC8THMNCRERENo8ZFiIiIpkq+T6gip4vFwxYiIiI5MqOxrCwS4iIiIhsHjMsREREciUAmDI1WT4JFgYsREREcmVPY1jYJUREREQ2jxkWIiIiuRIwcdCt2WpicQxYiIiI5IqzhIiIiIhsBzMsREREcqUFoDDxfJlgwEJERCRT9jRLiAELERGRXHEMCxEREZHtYIaFiIhIruwow8KAhYiISK7sKGBhlxARERHZPGZYiIiI5IrTmomIiMjW2dO0ZnYJERERkc1jhoWIiEiu7GjQLQMWIiIiudIKQGFC0KGVT8DCLiEiIiKyecywEBERyRW7hIiIiMj2mRiwgAELERERWZodZVg4hoWIiIhsHjMsREREcqUVMKlbR0azhBiwEBERyZXQPtpMOV8m2CVERERENo8ZFiIiIrmyo0G3DFiIiIjkyo7GsLBLiIiIiGweMyxERERyxS4hIiIisnkCJgYsZquJxbFLiIiIiGweMyxERERyxS4hIiIisnlaLQATFn/TymfhOAYsREREcmVHGRaOYSEiIiKbxwwLERGRXNlRhoUBCxERkVxxpVsiIiIi28EMCxERkUwJoYUQFZ/pY8q5lY0BCxERkVwJYVq3jozGsLBLiIiIiGweMyxERERyJUwcdCujDAsDFiIiIrnSagGFCeNQZDSGhV1CREREZPOYYSEiIpIrdgkRERGRrRNaLYQJXUKc1kxERESWZ0cZFo5hISIiIpvHDAsREZFcaQWgsI8MCwMWIiIiuRICgCnTmuUTsLBLiIiIiGweMyxEREQyJbQCwoQuISGjDAsDFiIiIrkSWpjWJSSfac3sEiIiIiKjJCQkICAgAC4uLggNDcXhw4fLLb99+3Y0a9YMLi4uaN26NZKSkoy+JwMWIiIimRJaYfJmrK1btyI6OhpxcXE4evQogoKCEBERgWvXruktf/DgQQwdOhRjxozBsWPHMGDAAAwYMAAnT5406r4KIacOLCIiIkJ+fj7c3NzQHf3hpKhW4es8FEVIw9fIy8uDSqUy6JzQ0FD87W9/w6pVqwAAWq0W/v7+mDJlCubMmVOq/ODBg1FQUIBdu3ZJ+5555hkEBwdj9erVBteVGRYiIiKZeogiPBQmbCgC8CgAKrk9ePBA7/0KCwuRkZGB8PBwaZ+DgwPCw8ORnp6u95z09HSd8gAQERFRZvmycNAtERGRzDg7O8PX1xcH1MaPBXmcq6sr/P39dfbFxcVh/vz5pcreuHEDGo0GPj4+Ovt9fHzw+++/672+Wq3WW16tVhtVTwYsREREMuPi4oKsrCwUFhaafC0hBBQKhc4+pVJp8nXNjQELERGRDLm4uMDFxaVS7+nl5QVHR0fk5OTo7M/JyYGvr6/ec3x9fY0qXxaOYSEiIiKDODs7IyQkBKmpqdI+rVaL1NRUhIWF6T0nLCxMpzwApKSklFm+LMywEBERkcGio6MRGRmJ9u3bo0OHDlixYgUKCgowevRoAMCoUaNQt25dxMfHAwCmTZuGbt264f3330ffvn2xZcsWHDlyBGvWrDHqvgxYiIiIyGCDBw/G9evXERsbC7VajeDgYCQnJ0sDa7Ozs+Hg8L8OnI4dO2Lz5s2YO3cu3nzzTTRu3Bg7d+5Eq1atjLov12EhIiIim8cxLERERGTzGLAQERGRzWPAQkRERDaPAQsRERHZPAYsREREZPMYsBAREZHNY8BCRERENo8BCxEREdk8BixERERk8xiwEBERkc1jwEJEREQ27/8BCa/j/R/p604AAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(recalc_landmass, cmap='viridis', interpolation='nearest')\n", + "\n", + "# Add a color bar to show the scale\n", + "plt.colorbar()\n", + "\n", + "# Add labels for better understanding (optional)\n", + "plt.title(\"Heatmap of 2D Array\")\n", + "plt.xlabel(\"X-axis\")\n", + "plt.ylabel(\"Y-axis\")\n", + "\n", + "# Show the plot\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "629846.0 4896000 0.12864501633986927\n", + "1638370.0 4896000 0.3346343954248366\n", + "354929.0 4896000 0.0724936683006536\n" + ] + } + ], + "source": [ + "print(recalc.sum(), recalc.shape[0] * recalc.shape[1], recalc.sum() / (recalc.shape[0] * recalc.shape[1]))\n", + "print(landmass.sum(), landmass.shape[0] * landmass.shape[1], landmass.sum() / (landmass.shape[0] * landmass.shape[1]))\n", + "print(recalc_landmass.sum(), recalc_landmass.shape[0] * recalc_landmass.shape[1], recalc_landmass.sum() / (recalc_landmass.shape[0] * recalc_landmass.shape[1]))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "fmin_l_bfgs_b\n", + "None\n" + ] + } + ], + "source": [ + "points = get_points(\"dump.sqlite\", until=pd.Timestamp(\"2024-03-30\"))\n", + "points[\"lon\"] = points.geometry.x\n", + "points[\"lat\"] = points.geometry.y\n", + "\n", + "X = points[[\"lon\", \"lat\"]].values\n", + "y = points[\"wait\"].values\n", + "X.shape, y.shape\n", + "\n", + "with open(\"models/kernel.pkl\", \"rb\") as file:\n", + " gpr = pickle.load(file)\n", + " \n", + "print(gpr.regressor.optimizer)\n", + "gpr.regressor.optimizer = None\n", + "print(gpr.regressor.optimizer)\n", + "\n", + "gpr = fit_gpr_silent(gpr, X, y)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Compute pixels that are expected to differ...\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b854e815933d4033b5a17f7c46a3df3c", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/3600 [00:00 61\u001b[0m \u001b[43mraster_maker\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msave_as_raster\u001b[49m()\n\u001b[1;32m 62\u001b[0m raster_maker\u001b[38;5;241m.\u001b[39mbuild_map() \u001b[38;5;66;03m# for march\u001b[39;00m\n\u001b[1;32m 63\u001b[0m a \u001b[38;5;241m=\u001b[39m raster_maker\u001b[38;5;241m.\u001b[39mraw_raster\n", + "\u001b[0;31mAttributeError\u001b[0m: 'MapBasedModel' object has no attribute 'save_as_raster'" + ] + } + ], + "source": [ + "version = \"mar_updated\"\n", + "model = gpr\n", + "verbose = True\n", + "\n", + "model_name = type(model).__name__\n", + "\n", + "raster_maker = MapBasedModel(\n", + " method=model_name,\n", + " region=region,\n", + " resolution=res,\n", + " version=version,\n", + " verbose=verbose,\n", + ")\n", + "\n", + "jan_map = load_numpy_map(resolution=res, method=method, version=\"jan\")\n", + "raster_maker.raw_raster = jan_map\n", + "\n", + "raster_maker.get_map_grid()\n", + "\n", + "print(\"Compute pixels that are expected to differ...\")\n", + "start = time.time()\n", + "to_predict = []\n", + "pixels_to_predict = []\n", + "for x, vertical_line in tqdm(\n", + " enumerate(raster_maker.grid.transpose()), total=len(raster_maker.grid.transpose())\n", + "):\n", + " for y, coords in enumerate(vertical_line):\n", + " if recalc_landmass[y][x] == 0:\n", + " continue\n", + " this_point = [float(coords[0]), float(coords[1])]\n", + " to_predict.append(this_point)\n", + " pixels_to_predict.append((y, x))\n", + " # batching the model calls\n", + " if len(to_predict) == 10000:\n", + " prediction = model.predict(np.array(to_predict), return_std=False)\n", + " for i, (y, x) in enumerate(pixels_to_predict):\n", + " raster_maker.raw_raster[y][x] = prediction[i]\n", + "\n", + " to_predict = []\n", + " pixels_to_predict = []\n", + " \n", + "prediction = model.predict(np.array(to_predict), return_std=False)\n", + "for i, (y, x) in enumerate(pixels_to_predict):\n", + " raster_maker.raw_raster[y][x] = prediction[i]\n", + "\n", + "print(f\"Time elapsed to compute full map: {time.time() - start}\")\n", + "print(\n", + " f\"For map of shape: {raster_maker.raw_raster.shape} that is {raster_maker.raw_raster.shape[0] * raster_maker.raw_raster.shape[1]} pixels and an effective time per pixel of {(time.time() - start) / (raster_maker.raw_raster.shape[0] * raster_maker.raw_raster.shape[1])} seconds\"\n", + ")\n", + "print((f\"Only {recalc_landmass.sum()} pixels were recalculated. That is {recalc_landmass.sum() / (raster_maker.raw_raster.shape[0] * raster_maker.raw_raster.shape[1]) * 100}% of the map.\"))\n", + "print(f\"And time per recalculated pixel was {(time.time() - start) / recalc_landmass.sum()} seconds\")\n", + "\n", + "save_numpy_map(\n", + " raster_maker.raw_raster,\n", + " region=region,\n", + " method=model_name,\n", + " resolution=res,\n", + " version=version,\n", + ")\n", + "\n", + "raster_maker.save_as_raster()\n", + "raster_maker.build_map() # for march\n", + "a = raster_maker.raw_raster" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading country shapes...\n", + "Time elapsed to load countries: 0.0734398365020752\n", + "Transforming heatmap...\n", + "max map waiting time: 545.8306419792199\n", + "min map waiting time: 0.9098548905539897\n", + "Time elapsed to transform heatmap: 0.15656590461730957\n", + "Plotting heatmap...\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# for january\n", + "version = \"jan\"\n", + "verbose = True\n", + "\n", + "model_name = type(model).__name__\n", + "\n", + "raster_maker = MapBasedModel(\n", + " method=model_name,\n", + " region=region,\n", + " resolution=res,\n", + " version=version,\n", + " verbose=verbose,\n", + ")\n", + "raster_maker.get_map_grid()\n", + "jan_map = load_numpy_map(resolution=res, method=method, version=\"jan\")\n", + "raster_maker.raw_raster = jan_map\n", + "raster_maker.save_as_raster()\n", + "raster_maker.build_map()\n", + "b = raster_maker.raw_raster" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "diff = ~np.isclose(a, b, atol=tolerance)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.imshow(diff, cmap='viridis', interpolation='nearest')\n", + "\n", + "# Add a color bar to show the scale\n", + "plt.colorbar()\n", + "\n", + "# Add labels for better understanding (optional)\n", + "plt.title(\"Heatmap of 2D Array\")\n", + "plt.xlabel(\"X-axis\")\n", + "plt.ylabel(\"Y-axis\")\n", + "\n", + "# Show the plot\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# determine area of map to update around newly added points" ] }, {