diff --git a/sourcecode/scoring/matrix_factorization/matrix_factorization.py b/sourcecode/scoring/matrix_factorization/matrix_factorization.py index e512bdde2..260d54d0a 100644 --- a/sourcecode/scoring/matrix_factorization/matrix_factorization.py +++ b/sourcecode/scoring/matrix_factorization/matrix_factorization.py @@ -9,6 +9,8 @@ import numpy as np import pandas as pd import torch +from scipy.sparse import csc_matrix +from scipy.sparse.linalg import svds logger = logging.getLogger("birdwatch.matrix_factorization") @@ -159,6 +161,68 @@ def get_note_and_rater_id_maps( return noteIdMap, raterIdMap, ratingFeaturesAndLabels + def _form_data_matrix(self, saveMemory=False): + """ + Args: + saveMemory: If saveMemory is False, the data is stored as a (number of notes) x (number of raters) numpy array + which may be large. However, this allows more manipulation to the array before the svd is taken, + for example the unseen values may be filled with nonzero's. + If saveMemory is True, the data is stored as a scipy csc_matrix, a sparse format similar to the + ratingsFeaturesAndLabels structure. In this case, I demean the filled data, and then set the unseen + data to 0. + + Returns: + Tuple[np.ndarray OR scipy.sparse.csc_matrix, pd.index, pd.index, float] + data_matrix: a dense or sparse representation of the notes x raters matrix + df_index: the index of the data_matrix; the notes' indices + df_columns: the cols of the data_matrix; the raters' indices + subtracted_intercept: the mean that was subtracted from the ratings data + + Calls without saveMemory are really large, I avoid ever having multiple of them around by deleting the reference + whenever I'm done with it, but one could also store it as attribute of self to trade off that memory for + not having to call this multiple times. + + Currently _form_data_df is only called when a Spectral Initialization occurs. + """ + if not saveMemory: + data_df = self.ratingFeaturesAndLabels.pivot(index='noteId', columns='raterParticipantId', values='helpfulNum') + if self.validateModelData is not None: + notes_map_to_id = self.noteIdMap.set_index(Constants.noteIndexKey)[c.noteIdKey] + rater_map_to_id = self.raterIdMap.set_index(Constants.raterIndexKey)[c.raterParticipantIdKey] + valid_row_pos = data_df.index.get_indexer(pd.Series(self.validateModelData.note_indexes.numpy()).map(notes_map_to_id)) # may need to call detach, but I don't think so since they don't have gradients? + valid_col_pos = data_df.columns.get_indexer(pd.Series(self.validateModelData.user_indexes.numpy()).map(rater_map_to_id)) + data_df.values[valid_row_pos, valid_col_pos] = np.nan + + data_matrix = data_df.values + mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \ + + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \ + - np.nanmean(data_matrix) + filled_matrix = np.where(np.isnan(data_matrix), mean_matrix, data_matrix) + + return filled_matrix, data_df.index, data_df.columns, np.nanmean(data_matrix) + + else: + if self.trainModelData is None: + rating_means = self.ratingFeaturesAndLabels["helpfulNum"].mean() + demeaned_ratings = self.ratingFeaturesAndLabels["helpfulNum"] - rating_means + data_matrix = csc_matrix((demeaned_ratings, + (self.ratingFeaturesAndLabels["noteIndex"], self.ratingFeaturesAndLabels["raterIndex"]))) + + rater_map_to_id = self.raterIdMap.set_index(Constants.raterIndexKey)[c.raterParticipantIdKey] + notes_map_to_id = self.noteIdMap.set_index(Constants.noteIndexKey)[c.noteIdKey] + + else: + rating_means = self.trainModelData.rating_labels.mean() + demeaned_ratings = self.trainModelData.rating_labels - rating_means + data_matrix = csc_matrix((demeaned_ratings, + (self.trainModelData.note_indexes, self.trainModelData.user_indexes)), + shape = (max(self.ratingFeaturesAndLabels["noteIndex"])+1, max(self.ratingFeaturesAndLabels["raterIndex"])+1)) + + rater_map_to_id = self.raterIdMap.set_index(Constants.raterIndexKey)[c.raterParticipantIdKey] + notes_map_to_id = self.noteIdMap.set_index(Constants.noteIndexKey)[c.noteIdKey] + + return data_matrix, notes_map_to_id.values, rater_map_to_id.values, rating_means + def _initialize_parameters( self, noteInit: Optional[pd.DataFrame] = None, @@ -183,17 +247,17 @@ def _initialize_parameters( noteInit = self.noteIdMap.merge( noteInit, on=c.noteIdKey, - how="left", - unsafeAllowed={c.noteIdKey, "noteIndex_y"}, + how="left" # , + # unsafeAllowed={c.noteIdKey, "noteIndex_y"}, my code wouldn't run with this line and I don't see it in the docs? ) - noteInit[c.internalNoteInterceptKey].fillna(0.0, inplace=True) + noteInit[c.internalNoteInterceptKey] = noteInit[c.internalNoteInterceptKey].fillna(0.0) # I had to get rid of these inplace=True's to silence a warning, but I think pandas would make a temporary copy anyway so not sure it saves memory self.mf_model.note_intercepts.weight.data = torch.tensor( np.expand_dims(noteInit[c.internalNoteInterceptKey].astype(np.float32).values, axis=1) ) for i in range(1, self._numFactors + 1): - noteInit[c.note_factor_key(i)].fillna(0.0, inplace=True) + noteInit[c.note_factor_key(i)] = noteInit[c.note_factor_key(i)].fillna(0.0) self.mf_model.note_factors.weight.data = torch.tensor( noteInit[[c.note_factor_key(i) for i in range(1, self._numFactors + 1)]] .astype(np.float32) @@ -205,13 +269,13 @@ def _initialize_parameters( logger.info("initializing users") userInit = self.raterIdMap.merge(userInit, on=c.raterParticipantIdKey, how="left") - userInit[c.internalRaterInterceptKey].fillna(0.0, inplace=True) + userInit[c.internalRaterInterceptKey] = userInit[c.internalRaterInterceptKey].fillna(0.0) self.mf_model.user_intercepts.weight.data = torch.tensor( np.expand_dims(userInit[c.internalRaterInterceptKey].astype(np.float32).values, axis=1) ) for i in range(1, self._numFactors + 1): - userInit[c.rater_factor_key(i)].fillna(0.0, inplace=True) + userInit[c.rater_factor_key(i)] = userInit[c.rater_factor_key(i)].fillna(0.0) self.mf_model.user_factors.weight.data = torch.tensor( userInit[[c.rater_factor_key(i) for i in range(1, self._numFactors + 1)]] .astype(np.float32) @@ -221,9 +285,7 @@ def _initialize_parameters( if globalInterceptInit is not None: if self._log: logger.info("initialized global intercept") - self.mf_model.global_intercept = torch.nn.parameter.Parameter( - torch.ones(1, 1, dtype=torch.float32) * globalInterceptInit - ) + self.mf_model.global_intercept.data = torch.ones(1, 1, dtype=torch.float32) * globalInterceptInit def _get_parameters_from_trained_model(self) -> Tuple[pd.DataFrame, pd.DataFrame]: """ @@ -434,7 +496,8 @@ def _fit_model( rating (torch.FloatTensor) """ assert self.mf_model is not None - self._create_train_validate_sets(validate_percent) + if self.trainModelData is None: + self._create_train_validate_sets(validate_percent) assert self.trainModelData is not None prev_loss = 1e10 @@ -495,6 +558,9 @@ def run_mf( noteInit: pd.DataFrame = None, userInit: pd.DataFrame = None, globalInterceptInit: Optional[float] = None, + useSpectralInit: Optional[bool] = False, + saveMemorySVD: bool = False, + additonalSpectralInitIters: Optional[int] = 0, specificNoteId: Optional[int] = None, validatePercent: Optional[float] = None, freezeRaterParameters: bool = False, @@ -511,6 +577,9 @@ def run_mf( noteInit (pd.DataFrame, optional) userInit (pd.DataFrame, optional) globalInterceptInit (float, optional). + useSpectralInit (bool, optional): Whether to use SVD to initialize the factors + saveMemorySVD (bool, optional): When useSpectralInit, whether to use a sparse scipy matrix + additionalSpectralInitIters (int, optional): How many times to reinitialize and refit with SVD specificNoteId (int, optional) Do approximate analysis to score a particular note Returns: @@ -550,7 +619,62 @@ def run_mf( self.mf_model.freeze_rater_and_global_parameters() self.prepare_features_and_labels(specificNoteId) + if useSpectralInit: + + self._create_train_validate_sets(validatePercent) + data_matrix, data_index, data_cols, subtracted_intercept = self._form_data_matrix(saveMemory=saveMemorySVD) + + U, S, Vt = svds(data_matrix, k=self._numFactors) + note_factor_init_vals = np.sqrt(S[0]) * U.T[0] + user_factor_init_vals = np.sqrt(S[0]) * Vt[0] + + noteInit = pd.DataFrame({ + c.noteIdKey: data_index, + c.note_factor_key(1): note_factor_init_vals, + c.internalNoteInterceptKey: np.zeros(len(note_factor_init_vals)) + }) + userInit = pd.DataFrame({ + c.raterParticipantIdKey: data_cols, + c.rater_factor_key(1): user_factor_init_vals, + c.internalRaterInterceptKey: np.zeros(len(user_factor_init_vals)) + }) + globalInterceptInit = subtracted_intercept + del data_matrix # save lots of memory if the data_matrix is numpy + # to further save memory, one could del data_df as soon as data_matrix is formed, but then would have to retrieve the ordering of ID's again when forming noteInit and userInit + + self._initialize_parameters(noteInit, userInit, globalInterceptInit) + train_loss, loss, validate_loss = self._fit_model(validatePercent) + + if useSpectralInit: + for _ in range(additonalSpectralInitIters): + data_df = self._form_data_df() + data_matrix = data_df.values + noteParams, raterParams = self._get_parameters_from_trained_model() + intercepts_matrix = np.add.outer(noteParams["internalNoteIntercept"].to_numpy(), raterParams["internalRaterIntercept"].to_numpy()) + if self._useGlobalIntercept: + intercepts_matrix = intercepts_matrix + self.mf_model.global_intercept.item() + filled_matrix = np.where(np.isnan(data_matrix), intercepts_matrix, data_matrix) + + U, S, Vt = svds(filled_matrix, k=self._numFactors) + note_factor_init_vals = np.sqrt(S[0]) * U.T[0] + user_factor_init_vals = np.sqrt(S[0]) * Vt[0] + + noteInit = pd.DataFrame({ + c.noteIdKey: data_df.index, + c.note_factor_key(1): note_factor_init_vals, + c.internalNoteInterceptKey: np.zeros(len(note_factor_init_vals)) + }) + userInit = pd.DataFrame({ + c.raterParticipantIdKey: data_df.columns, + c.rater_factor_key(1): user_factor_init_vals, + c.internalRaterInterceptKey: np.zeros(len(user_factor_init_vals)) + }) + del data_df, data_matrix + + self._initialize_parameters(noteInit, userInit, None) + train_loss, loss, validate_loss = self._fit_model(validatePercent) + if self._normalizedLossHyperparameters is not None: _, raterParams = self._get_parameters_from_trained_model() assert self.modelData is not None diff --git a/sourcecode/test_mf.ipynb b/sourcecode/test_mf.ipynb new file mode 100644 index 000000000..131c0c343 --- /dev/null +++ b/sourcecode/test_mf.ipynb @@ -0,0 +1,475 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Testing the Spectral Initialization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "I saw that ratings were initialized with a random uniform distribution, which I understand is borrowed from deep learning practice, but I thought in this case we might be able to do a little better. Since the Ekhart-Young theorem gives a closed-form solution to low-rank matrix factorization without intercepts, my idea was to use the SVD to initialize the factors as if the intercepts were all zero, and then to perform gradient optimization. " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "from scoring.matrix_factorization.matrix_factorization import MatrixFactorization\n", + "from scoring.process_data import preprocess_data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "ratings_df = pd.read_csv(\"ratings-00009.tsv\", sep='\\t')\n", + "preprocessed_ratings_df = preprocess_data(ratings=ratings_df, notes=None, noteStatusHistory=None, ratingsOnly=True)[1]" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "preprocessed_ratings_df_sample = pd.read_csv(\"ratings-00009-preprocessed.tsv\", sep='\\t') # in case I saved a preprocessed copy" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "all_spec_fitNoteParams, all_spec_fitRaterParams, all_spec_globalIntercept, all_spec_train_loss, all_spec_loss, all_spec_validate_loss = [], [], [], [], [], []\n", + "all_unif_fitNoteParams, all_unif_fitRaterParams, all_unif_globalIntercept, all_unif_train_loss, all_unif_loss, all_unif_validate_loss = [], [], [], [], [], []\n", + "for _ in range(50):\n", + " preprocessed_ratings_df_sample = preprocessed_ratings_df.sample(n=10000, replace=False)\n", + " test_MatrixFactorization = MatrixFactorization()\n", + " fitNoteParams, fitRaterParams, globalIntercept, train_loss, loss, validate_loss = test_MatrixFactorization.run_mf(ratings=preprocessed_ratings_df_sample, useSpectralInit=True, validatePercent=0.30)\n", + " all_spec_fitNoteParams.append(fitNoteParams); all_spec_fitRaterParams.append(fitRaterParams); all_spec_globalIntercept.append(globalIntercept); all_spec_train_loss.append(train_loss); all_spec_loss.append(loss); all_spec_validate_loss.append(validate_loss)\n", + " test_MatrixFactorization = MatrixFactorization()\n", + " fitNoteParams, fitRaterParams, globalIntercept, train_loss, loss, validate_loss = test_MatrixFactorization.run_mf(ratings=preprocessed_ratings_df_sample, useSpectralInit=False, validatePercent=0.30)\n", + " all_unif_fitNoteParams.append(fitNoteParams); all_unif_fitRaterParams.append(fitRaterParams); all_unif_globalIntercept.append(globalIntercept); all_unif_train_loss.append(train_loss); all_unif_loss.append(loss); all_unif_validate_loss.append(validate_loss)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "all_spec_fitNoteParams_30k, all_spec_fitRaterParams_30k, all_spec_globalIntercept_30k, all_spec_train_loss_30k, all_spec_loss_30k, all_spec_validate_loss_30k = [], [], [], [], [], []\n", + "all_unif_fitNoteParams_30k, all_unif_fitRaterParams_30k, all_unif_globalIntercept_30k, all_unif_train_loss_30k, all_unif_loss_30k, all_unif_validate_loss_30k = [], [], [], [], [], []\n", + "for _ in range(10):\n", + " preprocessed_ratings_df_sample = preprocessed_ratings_df.sample(n=30000, replace=False)\n", + " test_MatrixFactorization = MatrixFactorization()\n", + " fitNoteParams, fitRaterParams, globalIntercept, train_loss, loss, validate_loss = test_MatrixFactorization.run_mf(ratings=preprocessed_ratings_df_sample, useSpectralInit=True, validatePercent=0.30)\n", + " all_spec_fitNoteParams_30k.append(fitNoteParams); all_spec_fitRaterParams_30k.append(fitRaterParams); all_spec_globalIntercept_30k.append(globalIntercept); all_spec_train_loss_30k.append(train_loss); all_spec_loss_30k.append(loss); all_spec_validate_loss_30k.append(validate_loss)\n", + " test_MatrixFactorization = MatrixFactorization()\n", + " fitNoteParams, fitRaterParams, globalIntercept, train_loss, loss, validate_loss = test_MatrixFactorization.run_mf(ratings=preprocessed_ratings_df_sample, useSpectralInit=False, validatePercent=0.30)\n", + " all_unif_fitNoteParams_30k.append(fitNoteParams); all_unif_fitRaterParams_30k.append(fitRaterParams); all_unif_globalIntercept_30k.append(globalIntercept); all_unif_train_loss_30k.append(train_loss); all_unif_loss_30k.append(loss); all_unif_validate_loss_30k.append(validate_loss)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "all_spec_fitNoteParams_dense, all_spec_fitRaterParams_dense, all_spec_globalIntercept_dense, all_spec_train_loss_dense, all_spec_loss_dense, all_spec_validate_loss_dense = [], [], [], [], [], []\n", + "all_unif_fitNoteParams_dense, all_unif_fitRaterParams_dense, all_unif_globalIntercept_dense, all_unif_train_loss_dense, all_unif_loss_dense, all_unif_validate_loss_dense = [], [], [], [], [], []\n", + "for _ in range(50):\n", + " all_noteIds = preprocessed_ratings_df[\"noteId\"].unique()\n", + " all_raterIds = preprocessed_ratings_df[\"raterParticipantId\"].unique()\n", + " notes_sample = np.random.choice(all_noteIds, size=10000, replace=False)\n", + " raters_sample = np.random.choice(all_raterIds, size=10000, replace=False)\n", + " preprocessed_ratings_df_sample_dense = preprocessed_ratings_df[preprocessed_ratings_df[\"noteId\"].isin(notes_sample) & preprocessed_ratings_df[\"raterParticipantId\"].isin(raters_sample)]\n", + "\n", + " test_MatrixFactorization = MatrixFactorization()\n", + " fitNoteParams, fitRaterParams, globalIntercept, train_loss, loss, validate_loss = test_MatrixFactorization.run_mf(ratings=preprocessed_ratings_df_sample_dense, useSpectralInit=True, validatePercent=0.30)\n", + " all_spec_fitNoteParams_dense.append(fitNoteParams); all_spec_fitRaterParams_dense.append(fitRaterParams); all_spec_globalIntercept_dense.append(globalIntercept); all_spec_train_loss_dense.append(train_loss); all_spec_loss_dense.append(loss); all_spec_validate_loss_dense.append(validate_loss)\n", + " test_MatrixFactorization = MatrixFactorization()\n", + " fitNoteParams, fitRaterParams, globalIntercept, train_loss, loss, validate_loss = test_MatrixFactorization.run_mf(ratings=preprocessed_ratings_df_sample_dense, useSpectralInit=False, validatePercent=0.30)\n", + " all_unif_fitNoteParams_dense.append(fitNoteParams); all_unif_fitRaterParams_dense.append(fitRaterParams); all_unif_globalIntercept_dense.append(globalIntercept); all_unif_train_loss_dense.append(train_loss); all_unif_loss_dense.append(loss); all_unif_validate_loss_dense.append(validate_loss)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "all_spec_fitNoteParams_30k_dense, all_spec_fitRaterParams_30k_dense, all_spec_globalIntercept_30k_dense, all_spec_train_loss_30k_dense, all_spec_loss_30k_dense, all_spec_validate_loss_30k_dense = [], [], [], [], [], []\n", + "all_unif_fitNoteParams_30k_dense, all_unif_fitRaterParams_30k_dense, all_unif_globalIntercept_30k_dense, all_unif_train_loss_30k_dense, all_unif_loss_30k_dense, all_unif_validate_loss_30k_dense = [], [], [], [], [], []\n", + "for _ in range(10):\n", + " all_noteIds = preprocessed_ratings_df[\"noteId\"].unique()\n", + " all_raterIds = preprocessed_ratings_df[\"raterParticipantId\"].unique()\n", + " notes_sample = np.random.choice(all_noteIds, size=30000, replace=False)\n", + " raters_sample = np.random.choice(all_raterIds, size=30000, replace=False)\n", + " preprocessed_ratings_df_sample_dense = preprocessed_ratings_df[preprocessed_ratings_df[\"noteId\"].isin(notes_sample) & preprocessed_ratings_df[\"raterParticipantId\"].isin(raters_sample)]\n", + "\n", + " test_MatrixFactorization = MatrixFactorization()\n", + " fitNoteParams, fitRaterParams, globalIntercept, train_loss, loss, validate_loss = test_MatrixFactorization.run_mf(ratings=preprocessed_ratings_df_sample_dense, useSpectralInit=True, validatePercent=0.30)\n", + " all_spec_fitNoteParams_30k_dense.append(fitNoteParams); all_spec_fitRaterParams_30k_dense.append(fitRaterParams); all_spec_globalIntercept_30k_dense.append(globalIntercept); all_spec_train_loss_30k_dense.append(train_loss); all_spec_loss_30k_dense.append(loss); all_spec_validate_loss_30k_dense.append(validate_loss)\n", + " test_MatrixFactorization = MatrixFactorization()\n", + " fitNoteParams, fitRaterParams, globalIntercept, train_loss, loss, validate_loss = test_MatrixFactorization.run_mf(ratings=preprocessed_ratings_df_sample_dense, useSpectralInit=False, validatePercent=0.30)\n", + " all_unif_fitNoteParams_30k_dense.append(fitNoteParams); all_unif_fitRaterParams_30k_dense.append(fitRaterParams); all_unif_globalIntercept_30k_dense.append(globalIntercept); all_unif_train_loss_30k_dense.append(train_loss); all_unif_loss_30k_dense.append(loss); all_unif_validate_loss_30k_dense.append(validate_loss)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Results\n", + "\n", + "I found the results a bit surprising! I expected the spectral initialization to guide the optimizer to a good part of the training loss landscape, so I thought the training and test loss would both improve a little. Instead I found that sometimes there was training loss improvement, but improvement was most visible in test loss. My best guess is that this may have something to do with the well-posedness of taking the SVD. Perhaps since the SVD is (speaking loosely) known to vary smoothly with the matrix entries, it guides to an optimum that's robust to changes in those entries, and thus better generalizing. I don't have any less hand-wavey way of explaining it, but if the reader does please let me know! If it turns out experimentally that the SVD is sufficiently robust to new matrix entries, the spectral initialization may also provide a way of making note ratings consistent between algorithm runs, while avoiding getting stuck in a less principled part of the landscape as initializing with the previous day's run might. \n", + "\n", + "I have not tested the spectral initialization when using `NormalizedLoss`, or against a uniform initialization using `NormalizedLoss`. I noticed that the default learning rate when using a special initiailization is different from when using the uniform, but I did not observe a difference when I tried using the smaller one in my small amount of testing.\n", + "\n", + "Since I'm running this all on my laptop cpu, I was limited to testing on small samples of the full community notes data. I ran 50 tests using a sample of 10k, and 10 tests using a sample of 30k. Sampling from a sparse matrix is tricky, and I'm not sure how to best represent the full data. For the \"sparse\" samples selected below, I randomly sampled ratings (each a (rater, note, rating) tuple), which I found intuitive at first. But, especially for the 10k sample I became concerned with the number of rows and columns that only had one entry. So for the \"dense\" samples below, I sampled either 10k or 30k notes and 10k or 30k raters, and then selected all ratings from the dataset (which is itself 1/10 of all released data) where both the rater and note were in the sample. This led to a much denser (but still very sparse) ratings matrix. \n", + "\n", + "As a sanity check, I also took a look at the values of parameters returned by both initializations. Differences were present, but minimal. The reasons for those differences could be interesting to continue to ponder. The global intercept was an exception, which I write a bit more about at the bottom. \n", + "\n", + "Unfortunately SVD is expensive to compute, and also with default algorithms requires the formation of the full raters-by-notes matrix, which I noticed the sourcecode takes care to avoid. If you intentionally have avoided ever using SVD solely because of its polyomial time and space use, then consider this a fun test! But, while running the entire SVD every hour may be intractable, I think SVD's fast rank-one updating procedures could make its use practically feasible for community notes' purposes. Additionally, I'm not an expert but I believe there exist algorithms to get the top of the SVD without ever actually forming the full raters-by-notes matrix.\n", + "\n", + "In testing, I caught a sneaky bug on line 245 of the pushed code. When changing what `self.mf_model.global_intercept` references entirely, as the code did previously, the optimizer loses track of it and will not update it during optimization. I believe updating `self.mf_model.global_intercept.data` instead should fix this. Even if you're not interested in the SVD stuff, I hope you'll make this quick fix, and maybe we can save the next developer a good amount of debugging pain :). " + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\iijof\\AppData\\Local\\Temp\\ipykernel_5220\\1014462041.py:21: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " fig.show()\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/MAAAGbCAYAAACIxMC9AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABx80lEQVR4nO3dd3gUVfv/8c8mIYVUWgoQegkdpAlIExAiVVCUByUggo8EpKkYlRJb7KBIEaSpIIgK8qiIgBSFAKGEIhh6lQRFSCgSIDm/P/yxX5YkkMAmm43v13XNpXPm7Jn7zG6GvffMnLEYY4wAAAAAAIDTcHF0AAAAAAAAIGdI5gEAAAAAcDIk8wAAAAAAOBmSeQAAAAAAnAzJPAAAAAAAToZkHgAAAAAAJ0MyDwAAAACAkyGZBwAAAADAyZDMAwAAAADgZEjmAQA59sMPP6hu3bry9PSUxWLR2bNnHR0S8plWrVqpVatWjg4jx1avXi2LxaIvv/zS0aHc0rVYV69e7ehQAAAOQDIPAPnE7NmzZbFYtHnzZkeHclOnT59Wz5495eXlpUmTJunTTz+Vt7d3ru5z586devDBB1W2bFl5enqqVKlSateunSZOnJir+3W0P/74Q0OHDlVYWJi8vLwUGBioRo0aadSoUTp//ryjw8sXXnvtNXXp0kVBQUGyWCwaN25clnVPnDihnj17KiAgQH5+furatasOHjxot1gOHz4si8ViXVxcXFS0aFGFh4crNjb2ttudPHmyZs+ebbc4AQAFg5ujAwAAOJe4uDidO3dOr7zyitq2bZvr+1u/fr1at26tMmXKaMCAAQoODtaxY8e0YcMGvf/++xoyZEiux+AIf/31lxo0aKCUlBQ9/vjjCgsL0+nTp7Vjxw5NmTJFTz31lHx8fBwdpsO99NJLCg4OVr169bRs2bIs650/f16tW7dWcnKyXnjhBRUqVEjjx49Xy5YtFR8fr2LFitktpl69eun+++9XWlqa9u7dq8mTJ6t169aKi4tTrVq1ctze5MmTVbx4cfXt29emvEWLFvr777/l7u5up8gBAM6EZB4AkCOnTp2SJAUEBNitzQsXLmQ5uv/aa6/J399fcXFxGfZ5LZa8dLNY7WnGjBk6evSo1q1bp6ZNm9psS0lJIYH7/w4dOqRy5crpzz//VIkSJbKsN3nyZO3bt0+bNm1Sw4YNJUnh4eGqWbOm3n33Xb3++ut2i+muu+7So48+al1v3ry5wsPDNWXKFE2ePNlu+3FxcZGnp6fd2gMAOBcuswcAJ7Nt2zaFh4fLz89PPj4+atOmjTZs2GBT58qVK4qOjlblypXl6empYsWK6Z577tHy5cutdRITE9WvXz+VLl1aHh4eCgkJUdeuXXX48OEs992qVStFRERIkho2bCiLxWIzWrhw4ULVr19fXl5eKl68uB599FGdOHHCpo2+ffvKx8dHBw4c0P333y9fX1/17t07y30eOHBANWrUyPTHg8DAQJt1i8WiwYMHa+7cuapatao8PT1Vv359rV271qbekSNHNGjQIFWtWlVeXl4qVqyYHnrooQx9v3brw5o1azRo0CAFBgaqdOnSkqRz585p2LBhKleunDw8PBQYGKh27dpp69atNm1s3LhRHTp0kL+/vwoXLqyWLVtq3bp1Wfb3+n67urrq7rvvzrDNz8/PJon7+eef9dBDD6lMmTLy8PBQaGiohg8frr///tvmddeO/dGjR9WpUyf5+PioVKlSmjRpkqR/bme499575e3trbJly2revHmZHo+1a9fqySefVLFixeTn56c+ffrozJkzt+xTamqqxo4dq0qVKlnjfO6555SamnrL12alXLly2ar35ZdfqmHDhtZEXpLCwsLUpk0bffHFF7eMu1OnTvL399f69etzHGPz5s0l/fOeXm/WrFm69957FRgYKA8PD1WvXl1TpkyxqVOuXDn9+uuvWrNmjfXy/WtzEWR2z3yrVq1Us2ZN7d69W61bt1bhwoVVqlQpvfXWWxniOnLkiLp06SJvb28FBgZq+PDhWrZsWYY29+3bpx49eig4OFienp4qXbq0HnnkESUnJ+f4WAAA7IeReQBwIr/++quaN28uPz8/PffccypUqJA++ugjtWrVSmvWrFHjxo0lSePGjVNMTIyeeOIJNWrUSCkpKdq8ebO2bt2qdu3aSZJ69OihX3/9VUOGDFG5cuV06tQpLV++XEePHs0yQXrxxRdVtWpVTZs2TS+//LLKly+vihUrSvon0evXr58aNmyomJgYJSUl6f3339e6deu0bds2m2T86tWrat++ve655x698847Kly4cJZ9Llu2rGJjY7Vr1y7VrFnzlsdozZo1WrBggZ5++ml5eHho8uTJ6tChgzZt2mR9fVxcnNavX69HHnlEpUuX1uHDhzVlyhS1atVKu3fvzhDPoEGDVKJECY0ZM0YXLlyQJP33v//Vl19+qcGDB6t69eo6ffq0fvnlF+3Zs0d33XWXJOmnn35SeHi46tevr7Fjx8rFxcWawP38889q1KjRTfudlpamTz/91PoDSlYWLlyoixcv6qmnnlKxYsW0adMmTZw4UcePH9fChQtt6qalpSk8PFwtWrTQW2+9pblz52rw4MHy9vbWiy++qN69e6t79+6aOnWq+vTpoyZNmqh8+fI2bQwePFgBAQEaN26cEhISNGXKFB05csSaXGYmPT1dXbp00S+//KKBAweqWrVq2rlzp8aPH6+9e/dq8eLFN+3jnUhPT9eOHTv0+OOPZ9jWqFEj/fjjjzp37px8fX0zbP/777/VtWtXbd68WStWrLD5MSC7rv1IVKRIEZvyKVOmqEaNGurSpYvc3Nz0v//9T4MGDVJ6eroiIyMlSRMmTNCQIUPk4+OjF198UZIUFBR00/2dOXNGHTp0UPfu3dWzZ099+eWXGjVqlGrVqqXw8HBJ/1xhcu+99+rkyZMaOnSogoODNW/ePK1atcqmrcuXL6t9+/ZKTU3VkCFDFBwcrBMnTujbb7/V2bNn5e/vn+PjAQCwEwMAyBdmzZplJJm4uLgs63Tr1s24u7ubAwcOWMt+//134+vra1q0aGEtq1OnjunYsWOW7Zw5c8ZIMm+//bZd4rx8+bIJDAw0NWvWNH///be1/NtvvzWSzJgxY6xlERERRpJ5/vnns7W/H3/80bi6uhpXV1fTpEkT89xzz5lly5aZy5cvZ6gryUgymzdvtpYdOXLEeHp6mgceeMBadvHixQyvjY2NNZLMJ598kqGv99xzj7l69apNfX9/fxMZGZll3Onp6aZy5cqmffv2Jj093Wbf5cuXN+3atbtpvxMTE02JEiWMJBMWFmb++9//mnnz5pmzZ89mqJtZf2JiYozFYjFHjhyxll079q+//rq17MyZM8bLy8tYLBYzf/58a/lvv/1mJJmxY8dmOB7169e3Of5vvfWWkWS++eYba1nLli1Ny5YtreuffvqpcXFxMT///LNNnFOnTjWSzLp16256PG7ljz/+yBDvjdtefvnlDNsmTZpkJJnffvvNGGPMqlWrjCSzcOFCc+7cOdOyZUtTvHhxs23btlvGcOjQISPJREdHmz/++MMkJiaan3/+2TRs2NDa5vUye9/at29vKlSoYFNWo0YNm2N5zbVYV61aZS1r2bJlhs9xamqqCQ4ONj169LCWvfvuu0aSWbx4sbXs77//NmFhYTZtbtu2LdPYAQCOx2X2AOAk0tLS9OOPP6pbt26qUKGCtTwkJET/+c9/9MsvvyglJUXSP/ez//rrr9q3b1+mbXl5ecnd3V2rV6/O1uXRt7J582adOnVKgwYNsrn8u2PHjgoLC9N3332X4TVPPfVUttpu166dYmNj1aVLF23fvl1vvfWW2rdvr1KlSmnJkiUZ6jdp0kT169e3rpcpU0Zdu3bVsmXLlJaWJumf/l9z5coVnT59WpUqVVJAQECGy+QlacCAAXJ1dbUpCwgI0MaNG/X7779nGnd8fLz27dun//znPzp9+rT+/PNP/fnnn7pw4YLatGmjtWvXKj09Pct+BwUFafv27frvf/+rM2fOaOrUqfrPf/6jwMBAvfLKKzLGWOte358LFy7ozz//VNOmTWWM0bZt2zK0/cQTT9j0o2rVqvL29lbPnj2t5VWrVlVAQECms70PHDhQhQoVsq4/9dRTcnNz0/fff59lfxYuXKhq1aopLCzMeiz+/PNP3XvvvZKUYUTYnq7dbuDh4ZFh27XP6423JCQnJ+u+++7Tb7/9ptWrV6tu3brZ3t/YsWNVokQJBQcHq3nz5tqzZ4/effddPfjggzb1rn/fkpOT9eeff6ply5Y6ePDgHV3C7uPjY3PPvru7uxo1amTzXv7www8qVaqUunTpYi3z9PTUgAEDbNq6NvK+bNkyXbx48bZjAgDYH8k8ADiJP/74QxcvXlTVqlUzbKtWrZrS09N17NgxSdLLL7+ss2fPqkqVKqpVq5aeffZZ7dixw1rfw8NDb775ppYuXaqgoCDrJdeJiYm3FduRI0ckKdPYwsLCrNuvcXNzs957nh0NGzbU119/rTNnzmjTpk2KiorSuXPn9OCDD2r37t02dStXrpzh9VWqVNHFixf1xx9/SPoncRszZoxCQ0Pl4eGh4sWLq0SJEjp79mymSdSNl5lL0ltvvaVdu3YpNDRUjRo10rhx42ySpWs/pERERKhEiRI2y8cff6zU1NRbJmwhISGaMmWKTp48qYSEBH3wwQfWy/1nzJhhrXf06FH17dtXRYsWlY+Pj0qUKKGWLVtKUoZ9eHp6Zpgozt/fX6VLl85wiby/v3+mP/bceIx9fHwUEhJy0/kW9u3bp19//TXDsahSpYqk3J3M8FrSnNm9+ZcuXbKpc82wYcMUFxenFStWqEaNGjna38CBA7V8+XL973//s85dcO2HpOutW7dObdu2lbe3twICAlSiRAm98MILkjK+bzmR2XtZpEgRm/fyyJEjqlixYoZ6lSpVslkvX768RowYoY8//ljFixdX+/btNWnSJO6XB4B8gHvmAaAAatGihQ4cOKBvvvlGP/74oz7++GONHz9eU6dOtY7KDhs2TJ07d9bixYu1bNkyjR49WjExMfrpp59Ur169XI3Pw8NDLi45/z3Z3d3dOolZlSpV1K9fPy1cuFBjx47NUTtDhgzRrFmzNGzYMDVp0kT+/v6yWCx65JFHMh0tvzHRk6SePXuqefPmWrRokX788Ue9/fbbevPNN/X1118rPDzc2s7bb7+d5ahudh8tZ7FYVKVKFVWpUkUdO3ZU5cqVNXfuXD3xxBNKS0tTu3bt9Ndff2nUqFEKCwuTt7e3Tpw4ob59+2boz41XGNyq/PorAO5Eenq6atWqpffeey/T7aGhoXbZT2aKFi0qDw8PnTx5MsO2a2UlS5a0Ke/atavmz5+vN954Q5988kmOPq+VK1e2PraxU6dOcnV11fPPP6/WrVurQYMGkv6ZDK9NmzYKCwvTe++9p9DQULm7u+v777/X+PHjb3rVxq3Y+71899131bdvX+v55Omnn1ZMTIw2bNiQox/lAAD2RTIPAE6iRIkSKly4sBISEjJs++233+Ti4mKTEBUtWlT9+vVTv379dP78ebVo0ULjxo2zucS6YsWKGjlypEaOHKl9+/apbt26evfdd/XZZ5/lKLayZctKkhISEqyXTV+TkJBg3W5P15KiGxO0zG4t2Lt3rwoXLmwdkf7yyy8VERGhd99911rn0qVLOnv2bI5iCAkJ0aBBgzRo0CCdOnVKd911l1577TWFh4dbJwb08/OzJnb2UKFCBRUpUsTa7507d2rv3r2aM2eO+vTpY613/ZML7G3fvn1q3bq1df38+fM6efKk7r///ixfU7FiRW3fvl1t2rTJcpK83OLi4qJatWpp8+bNGbZt3LhRFSpUyDD5Xbdu3XTfffepb9++8vX1zTDLfE68+OKLmj59ul566SX98MMPkqT//e9/Sk1N1ZIlS1SmTBlr3cxuN8iN41W2bFnt3r1bxhib9vfv359p/Vq1aqlWrVp66aWXtH79ejVr1kxTp07Vq6++avfYAADZw2X2AOAkXF1ddd999+mbb76xuZw5KSlJ8+bN0z333CM/Pz9J0unTp21e6+Pjo0qVKlkvM7548aL18uJrKlasKF9f39t6TFiDBg0UGBioqVOn2rx+6dKl2rNnjzp27JjjNq9ZtWpVpiOK1+7PvvHS/tjYWJv73o8dO6ZvvvlG9913n3XE0tXVNUObEydOzPRS6MykpaVluMw4MDBQJUuWtPa/fv36qlixot555x2dP38+QxvXLvnPysaNG60z519v06ZNOn36tLXf1/p0fX+MMXr//fez1ZfbMW3aNF25csW6PmXKFF29etU6U3pmevbsqRMnTmj69OkZtv3999+Z9tWeHnzwQcXFxdkk9AkJCfrpp5/00EMPZfqaPn366IMPPtDUqVM1atSo2953QECAnnzySS1btkzx8fGSMn/fkpOTNWvWrAyv9/b2zvEPTbfSvn17nThxwmbeiUuXLmV4f1JSUnT16lWbslq1asnFxeWOHikIALhzjMwDQD4zc+ZM6+jd9YYOHapXX31Vy5cv1z333KNBgwbJzc1NH330kVJTU22eI129enW1atVK9evXV9GiRbV582brY9Skf0aq27Rpo549e6p69epyc3PTokWLlJSUpEceeSTHMRcqVEhvvvmm+vXrp5YtW6pXr17WR9OVK1dOw4cPv+3jMWTIEF28eFEPPPCAwsLCdPnyZa1fv14LFixQuXLl1K9fP5v6NWvWVPv27W0eTSdJ0dHR1jqdOnXSp59+Kn9/f1WvXl2xsbFasWKFihUrlq2Yzp07p9KlS+vBBx9UnTp15OPjoxUrViguLs462u/i4qKPP/5Y4eHhqlGjhvr166dSpUrpxIkTWrVqlfz8/PS///0vy318+umnmjt3rh544AHVr19f7u7u2rNnj2bOnClPT0/rvdVhYWGqWLGinnnmGZ04cUJ+fn766quv7DKxYVYuX75s/fwkJCRo8uTJuueee2wmU7vRY489pi+++EL//e9/tWrVKjVr1kxpaWn67bff9MUXX2jZsmXWqy3GjRun6OhorVq1yvpM9ax8+umnOnLkiHVytrVr11pHix977DHrVSGDBg3S9OnT1bFjRz3zzDMqVKiQ3nvvPQUFBWnkyJFZtj948GClpKToxRdflL+/v/W459TQoUM1YcIEvfHGG5o/f77uu+8+ubu7q3PnznryySd1/vx5TZ8+XYGBgRmuNqlfv76mTJmiV199VZUqVVJgYGCGK2By6sknn9SHH36oXr16aejQoQoJCdHcuXOtEwJeG63/6aefNHjwYD300EOqUqWKrl69qk8//VSurq7q0aPHHcUAALhDjppGHwBg69pjv7Jajh07ZowxZuvWraZ9+/bGx8fHFC5c2LRu3dqsX7/epq1XX33VNGrUyAQEBBgvLy8TFhZmXnvtNevjxP78808TGRlpwsLCjLe3t/H39zeNGzc2X3zxRbbjzOwRegsWLDD16tUzHh4epmjRoqZ3797m+PHjNnUiIiKMt7d3to/L0qVLzeOPP27CwsKMj4+PcXd3N5UqVTJDhgwxSUlJNnUlmcjISPPZZ5+ZypUrGw8PD1OvXj2bR3cZ88/j2Pr162eKFy9ufHx8TPv27c1vv/1mypYtayIiIm7Z19TUVPPss8+aOnXqGF9fX+Pt7W3q1KljJk+enCH+bdu2me7du5tixYoZDw8PU7ZsWdOzZ0+zcuXKm/Z7x44d5tlnnzV33XWXKVq0qHFzczMhISHmoYceMlu3brWpu3v3btO2bVvj4+NjihcvbgYMGGC2b99uJJlZs2ZZ62V17Fu2bGlq1KiRobxs2bI2jzi8djzWrFljBg4caIoUKWJ8fHxM7969zenTpzO0eePj1C5fvmzefPNNU6NGDePh4WGKFCli6tevb6Kjo01ycrK13siRI43FYjF79uy56TG6tp+s/mZufN+PHTtmHnzwQePn52d8fHxMp06dzL59+2zqXP9ouus999xzRpL58MMPs4zl2qPpsnrkY9++fY2rq6vZv3+/McaYJUuWmNq1axtPT09Trlw58+abb5qZM2caSebQoUPW1yUmJpqOHTsaX19fI8l6XLN6NF1m72VERIQpW7asTdnBgwdNx44djZeXlylRooQZOXKk+eqrr4wks2HDBmudxx9/3FSsWNF4enqaokWLmtatW5sVK1ZkeRwAAHnDYoydZrYBAMDBLBaLIiMj9eGHHzo6lAJp9uzZ6tevn+Li4qyj6LmhUaNGKlu2rBYuXJhr+0DmJkyYoOHDh+v48eMqVaqUo8MBANwEl9kDAIB8IyUlRdu3b9ecOXMcHUqB9/fff9s8qeHSpUv66KOPVLlyZRJ5AHACJPMAACDf8PPzY2K1PNK9e3eVKVNGdevWVXJysj777DP99ttvmjt3rqNDAwBkA8k8AADAv1D79u318ccfa+7cuUpLS1P16tU1f/58Pfzww44ODQCQDdwzDwAAAACAk+E58wAAAAAAOBmSeQAAAAAAnAzJPAAAAAAAToZkHgAAAAAAJ0MyDwAAAACAkyGZBwAAAADAyZDMAwAAAADgZEjmAQAAAABwMiTzAAAAAAA4GZJ5AAAAAACcDMk8AAAAAABOhmQeAAAAAAAnQzIPAAAAAICTIZkHAAAAAMDJkMwDAAAAAOBkSOYBAAAAAHAyJPMAAAAAADgZknkAAAAAAJwMyTwAAAAAAE6GZB4AAAAAACfj5ugAclt6erp+//13+fr6ymKxODocAE7GGKNz586pZMmScnEpWL9/cn4EcKcK6jmS8yOAO5UX58cCn8z//vvvCg0NdXQYAJzcsWPHVLp0aUeHYVecHwHYS0E7R3J+BGAvuXl+LPDJvK+vr6R/DqKfn5+DowHgbFJSUhQaGmo9lxQknB8B3KmCeo7k/AjgTuXF+bHAJ/PXLo3y8/PjZAzgthXEyyw5PwKwl4J2juT8CMBecvP8WHBubgIAAAAA4F+CZB4AAAAAACdDMg8AAAAAgJMp8PfMAwAAAPZmjNHVq1eVlpbm6FCQDxQqVEiurq6ODgP/MiTzAAAAQA5cvnxZJ0+e1MWLFx0dCvIJi8Wi0qVLy8fHx9Gh4F+EZB4AAADIpvT0dB06dEiurq4qWbKk3N3dC9xs/sgZY4z++OMPHT9+XJUrV2aEHnmGZB4AAADIpsuXLys9PV2hoaEqXLiwo8NBPlGiRAkdPnxYV65cIZlHnnHoBHjjxo2TxWKxWcLCwqzbL126pMjISBUrVkw+Pj7q0aOHkpKSHBgxAAAA8ru0tDSNHj1a5cuXl5eXlypWrKhXXnlFxhi77cPFhXmk8X+4OgOO4PCR+Ro1amjFihXWdTe3/wtp+PDh+u6777Rw4UL5+/tr8ODB6t69u9atW+eIUAEAAOAE3nzzTU2ZMkVz5sxRjRo1tHnzZvXr10/+/v56+umnHR0eANiFw5N5Nzc3BQcHZyhPTk7WjBkzNG/ePN17772SpFmzZqlatWrasGGD7r777rwOFQAAAE5g/fr16tq1qzp27ChJKleunD7//HNt2rTJwZHB3g4fPqzy5ctr27Ztqlu3br5tE8gNDr8+aN++fSpZsqQqVKig3r176+jRo5KkLVu26MqVK2rbtq21blhYmMqUKaPY2Ngs20tNTVVKSorNAgAAgH+Ppk2bauXKldq7d68kafv27frll18UHh6eaf1/y/fHP/74Q0899ZTKlCkjDw8PBQcHq3379nl+1avFYtHixYvzbH+tWrXSsGHDsl0/NDRUJ0+eVM2aNSVJq1evlsVi0dmzZ3MnQOA2OXRkvnHjxpo9e7aqVq2qkydPKjo6Ws2bN9euXbuUmJgod3d3BQQE2LwmKChIiYmJWbYZExOj6OjoXI7cjlbF5Pw1raPsHwcAOLnxy/fmqP7wdlVyKRIAjvb8888rJSVFYWFhcnV1VVpaml577TX17t070/r2+v6Y0/PQncrpeaxHjx66fPmy5syZowoVKigpKUkrV67U6dOncynC23f58mW5u7s7ZN+urq6ZXjnscNnJG8gT/lUcOjIfHh6uhx56SLVr11b79u31/fff6+zZs/riiy9uu82oqCglJydbl2PHjtkxYgAAAOR3X3zxhebOnat58+Zp69atmjNnjt555x3NmTMn0/r/hu+PZ8+e1c8//6w333xTrVu3VtmyZdWoUSNFRUWpS5cu1noWi0VTpkxReHi4vLy8VKFCBX355Zc2bR07dkw9e/ZUQECAihYtqq5du+rw4cM2dWbOnKkaNWrIw8NDISEhGjx4sKR/bnmQpAceeEAWi8W6Pm7cONWtW1cff/yxypcvL09PT0nSDz/8oHvuuUcBAQEqVqyYOnXqpAMHDtzRsShXrpxef/11Pf744/L19VWZMmU0bdo06/bDhw/LYrEoPj5ehw8fVuvWrSVJRYoUkcViUd++fe9o/4C9OPwy++sFBASoSpUq2r9/v4KDg3X58uUMl7MkJSXd9JcyDw8P+fn52SwAAAD493j22Wf1/PPP65FHHlGtWrX02GOPafjw4YqJyXxk89/w/dHHx0c+Pj5avHixUlNTb1p39OjR6tGjh7Zv367evXvrkUce0Z49eyRJV65cUfv27eXr66uff/5Z69atk4+Pjzp06KDLly9LkqZMmaLIyEgNHDhQO3fu1JIlS1SpUiVJUlxcnKR/5sI6efKkdV2S9u/fr6+++kpff/214uPjJUkXLlzQiBEjtHnzZq1cuVIuLi564IEHlJ6efkfH491331WDBg20bds2DRo0SE899ZQSEhIy1AsNDdVXX30lSUpISNDJkyf1/vvv39G+AXvJV8n8+fPndeDAAYWEhKh+/foqVKiQVq5cad2ekJCgo0ePqkmTJg6MEgAAAPnZxYsXMzw6ztXV9Y4TQGfm5uam2bNna86cOQoICFCzZs30wgsvaMeOHRnqPvTQQ3riiSdUpUoVvfLKK2rQoIEmTpwoSVqwYIHS09P18ccfq1atWqpWrZpmzZqlo0ePavXq1ZKkV199VSNHjtTQoUNVpUoVNWzY0HrPeokSJST9M4gXHBxsXZf+ubT+k08+Ub169VS7dm1J/9wa0L17d1WqVEl169bVzJkztXPnTu3evfuOjsf999+vQYMGqVKlSho1apSKFy+uVatWZajn6uqqokWLSpICAwMVHBwsf3//O9o3YC8OTeafeeYZrVmzRocPH9b69ev1wAMPyNXVVb169ZK/v7/69++vESNGaNWqVdqyZYv69eunJk2aMJM9AAAAstS5c2e99tpr+u6773T48GEtWrRI7733nh544AFHh+ZQPXr00O+//64lS5aoQ4cOWr16te666y7Nnj3bpt6NA2dNmjSxjsxv375d+/fvl6+vr3W0v2jRorp06ZIOHDigU6dO6ffff1ebNm1yHF/ZsmVtknvpn8mye/XqpQoVKsjPz896Wf61SbNv17UfC6R/bi0IDg7WqVOn7qhNIK85dAK848ePq1evXjp9+rRKlCihe+65Rxs2bLD+EY8fP14uLi7q0aOHUlNT1b59e02ePNmRIQMAACCfmzhxokaPHq1Bgwbp1KlTKlmypJ588kmNGTPG0aE5nKenp9q1a6d27dpp9OjReuKJJzR27Nhs3wd+/vx51a9fX3Pnzs2wrUSJEhmuiMgJb2/vDGWdO3dW2bJlNX36dJUsWVLp6emqWbOm9ZL+21WoUCGbdYvF8q++cgPOyaHJ/Pz582+63dPTU5MmTdKkSZPyKCIAAAA4O19fX02YMEETJkxwdCj5XvXq1TM8Jm7Dhg3q06ePzXq9evUkSXfddZcWLFigwMDALOcWKFeunFauXGmdOO5GhQoVUlpa2i1jO336tBISEjR9+nQ1b95ckvTLL79kp1t2dW1W/ezEDOSlfHXPPAAAAAD7O336tO6991599tln2rFjhw4dOqSFCxfqrbfeUteuXW3qLly4UDNnztTevXs1duxYbdq0yTobfe/evVW8eHF17dpVP//8sw4dOqTVq1fr6aef1vHjxyX9MzP9u+++qw8++ED79u3T1q1brffcS/+X7CcmJurMmTNZxlykSBEVK1ZM06ZN0/79+/XTTz9pxIgRuXB0bq5s2bKyWCz69ttv9ccff+j8+fN5HgOQGZJ5AAAAoIDz8fFR48aNNX78eLVo0UI1a9bU6NGjNWDAAH344Yc2daOjozV//nzVrl1bn3zyiT7//HNVr15dklS4cGGtXbtWZcqUUffu3VWtWjX1799fly5dso7UR0REaMKECZo8ebJq1KihTp06ad++fdb23333XS1fvlyhoaHWEf/MuLi4aP78+dqyZYtq1qyp4cOH6+23386Fo3NzpUqVUnR0tJ5//nkFBQVZf9gAHM1ijDGODiI3paSkyN/fX8nJyfnzMSOrMn9Eyk21jrJ/HAAyle/PIXegoPVt/PK9Oao/vF2VXIoE+PcoaOeRa27Wr0uXLunQoUM2z0IvSCwWixYtWqRu3bo5OhSnkiefi+zkDeQJ+UZenB8ZmQcAAAAAwMmQzAMAAAAA4GQcOps9AAAAgPyjgN+BCxQojMwDAAAAAOBkSOYBAAAAAHAyJPMAAAAAADgZknkAAAAAAJwMyTwAAAAAAE6GZB4AAAAAACdDMg8A+dDatWvVuXNnlSxZUhaLRYsXL7Zuu3LlikaNGqVatWrJ29tbJUuWVJ8+ffT77787LmAAwL9KuXLlNGHCBOt6YmKi2rVrJ29vbwUEBDgsrjsxe/Zsp40d/048Zx4A8qELFy6oTp06evzxx9W9e3ebbRcvXtTWrVs1evRo1alTR2fOnNHQoUPVpUsXbd682UERAwC0KiZv99c6KkfVW7Vqpbp169ok4dI/SeywYcN09uzZbLcVFxcnb29v6/r48eN18uRJxcfHy9/fP0dx5RaLxaJFixapW7du2ar/8MMP6/7777eujxs3TosXL1Z8fHzuBAjcIZJ5AMiHwsPDFR4enuk2f39/LV++3Kbsww8/VKNGjXT06FGVKVMmL0IEAPyLlShRwmb9wIEDql+/vipXrnzbbV6+fFnu7u53Gtpt8/LykpeXl8P2D+QUl9kDQAGQnJwsi8Vy08sDU1NTlZKSYrMAAHCjvn37qlu3bnrnnXcUEhKiYsWKKTIyUleuXLHWuf4y+3Llyumrr77SJ598IovFor59+0qSjh49qq5du8rHx0d+fn7q2bOnkpKSrG2MGzdOdevW1ccff6zy5cvL09NT0j8j6h999JE6deqkwoULq1q1aoqNjdX+/fvVqlUreXt7q2nTpjpw4EC2+3T48GFZLBZ9/fXXat26tQoXLqw6deooNjbWWuf6y+xnz56t6Ohobd++XRaLRRaLRbNnz769AwrkEpJ5AHByly5d0qhRo9SrVy/5+fllWS8mJkb+/v7WJTQ0NA+jBAA4k1WrVunAgQNatWqV5syZo9mzZ2eZzMbFxalDhw7q2bOnTp48qffff1/p6enq2rWr/vrrL61Zs0bLly/XwYMH9fDDD9u8dv/+/frqq6/09ddf21zO/sorr6hPnz6Kj49XWFiY/vOf/+jJJ59UVFSUNm/eLGOMBg8enON+vfjii3rmmWcUHx+vKlWqqFevXrp69WqGeg8//LBGjhypGjVq6OTJkzp58mSG2AFH4zJ7AHBiV65cUc+ePWWM0ZQpU25aNyoqSiNGjLCup6SkkNADADJVpEgRffjhh3J1dVVYWJg6duyolStXasCAARnqlihRQh4eHvLy8lJwcLAkafny5dq5c6cOHTpk/bfmk08+UY0aNRQXF6eGDRtK+ufS+k8++STDZfv9+vVTz549JUmjRo1SkyZNNHr0aLVv316SNHToUPXr1y/H/XrmmWfUsWNHSVJ0dLRq1Kih/fv3KywszKael5eXfHx85ObmZu0TkN8wMg8ATupaIn/kyBEtX778pqPykuTh4SE/Pz+bBQCAzNSoUUOurq7W9ZCQEJ06dSrbr9+zZ49CQ0NtfjSuXr26AgICtGfPHmtZ2bJlMyTyklS7dm3r/wcFBUmSatWqZVN26dKlHN8ydn27ISEhkpSjfgH5CSPzAOCEriXy+/bt06pVq1SsWDFHhwQAyOf8/PyUnJycofzs2bMZZqAvVKiQzbrFYlF6errdY7p+Rvys9m+xWLIsy2lM9mgDyC9I5gEgHzp//rz2799vXT906JDi4+NVtGhRhYSE6MEHH9TWrVv17bffKi0tTYmJiZKkokWLOnQmYABA/lW1alX9+OOPGcq3bt2qKlWq2HVf1apV07Fjx3Ts2DHr6Pzu3bt19uxZVa9e3a77yi3u7u5KS0tzdBhAlrjMHgDyoc2bN6tevXqqV6+eJGnEiBGqV6+exowZoxMnTmjJkiU6fvy46tatq5CQEOuyfv16B0cOAMivnnrqKe3du1dPP/20duzYoYSEBL333nv6/PPPNXLkSLvuq23btqpVq5Z69+6trVu3atOmTerTp49atmypBg0a2HVfuaVcuXLWH9P//PNPpaamOjokwAYj8wCQD7Vq1UrGmCy332wbAACZqVChgtauXasXX3xRbdu21eXLlxUWFqaFCxeqQ4cOdt2XxWLRN998oyFDhqhFixZycXFRhw4dNHHiRLvuJzf16NHD+ii7s2fPatasWdbH7gH5gcUU8G+EKSkp8vf3V3Jycv6c7GlVTM5f0zrK/nEAyFS+P4fcgYLWt/HL9+ao/vB29r2kFPg3KmjnkWtu1q9Lly7p0KFDNs9FB/Lkc5GdvIE8Id/Ii/Mjl9kDAAAAAOBkSOYBAAAAAHAyJPMAAAAoUMqVKyeLxZJhiYyMdHRoAGA3TIAHAACAAiUuLs7mkWK7du1Su3bt9NBDDzkwKgCwL5J5AAAAFCglSpSwWX/jjTdUsWJFtWzZ0kERAYD9kcwDAACgwLp8+bI+++wzjRgxQhaLJdM6qampNs8QT0lJuWW7BfyBUMghPg9wBJJ5AAAAFFiLFy/W2bNnb/p88JiYGEVHR2ervUKFCkmSLl68KC8vL3uEiALg8uXLkiRXV1fHBsLj6/5VSOYBAABQYM2YMUPh4eEqWbJklnWioqI0YsQI63pKSopCQ0Mzrevq6qqAgACdOnVKklS4cOEsR/zx75Cenq4//vhDhQsXlpsb6RXyDp82AAAAFEhHjhzRihUr9PXXX9+0noeHhzw8PLLdbnBwsCRZE3rAxcVFZcqU4Ycd5CmSeQAAABRIs2bNUmBgoDp27GjXdi0Wi0JCQhQYGKgrV67YtW04J3d3d7m48NRv5C2SeQAAABQ46enpmjVrliIiInLt0mdXV1fH3yMN4F+Ln48AAABQ4KxYsUJHjx7V448/7uhQACBXMDIPAACAAue+++7jcWEACjRG5gEAAAAAcDIk8wAAAAAAOBmSeQAAAAAAnAzJPAAAAAAAToZkHgAAAAAAJ0MyDwAAAACAkyGZBwAAAADAyZDMAwAAAADgZEjmAQAAAABwMiTzAAAAAAA4GZJ5AAAAAACcTL5J5t944w1ZLBYNGzbMWnbp0iVFRkaqWLFi8vHxUY8ePZSUlOS4IAEAAAAAyAfyRTIfFxenjz76SLVr17YpHz58uP73v/9p4cKFWrNmjX7//Xd1797dQVECAAAAAJA/ODyZP3/+vHr37q3p06erSJEi1vLk5GTNmDFD7733nu69917Vr19fs2bN0vr167VhwwYHRgwAAAAAgGM5PJmPjIxUx44d1bZtW5vyLVu26MqVKzblYWFhKlOmjGJjY7NsLzU1VSkpKTYLAAAAAAAFiZsjdz5//nxt3bpVcXFxGbYlJibK3d1dAQEBNuVBQUFKTEzMss2YmBhFR0fbO1QAAAAAAPINh43MHzt2TEOHDtXcuXPl6elpt3ajoqKUnJxsXY4dO2a3tgEAAAAAyA8clsxv2bJFp06d0l133SU3Nze5ublpzZo1+uCDD+Tm5qagoCBdvnxZZ8+etXldUlKSgoODs2zXw8NDfn5+NgsAAAAAAAWJwy6zb9OmjXbu3GlT1q9fP4WFhWnUqFEKDQ1VoUKFtHLlSvXo0UOSlJCQoKNHj6pJkyaOCBkAAAAAgHzBYcm8r6+vatasaVPm7e2tYsWKWcv79++vESNGqGjRovLz89OQIUPUpEkT3X333Y4IGQAAAACAfMHhs9nfzPjx49WpUyf16NFDLVq0UHBwsL7++mtHhwUAuW7t2rXq3LmzSpYsKYvFosWLF9tsN8ZozJgxCgkJkZeXl9q2bat9+/Y5JlgAAADkOYfOZn+j1atX26x7enpq0qRJmjRpkmMCygOxB0/n+DVNWudCIADylQsXLqhOnTp6/PHH1b179wzb33rrLX3wwQeaM2eOypcvr9GjR6t9+/bavXu3XScVBQAAQP6Ur5J5AMA/wsPDFR4enuk2Y4wmTJigl156SV27dpUkffLJJwoKCtLixYv1yCOP5GWoAAAAcIB8fZk9ACCjQ4cOKTExUW3btrWW+fv7q3HjxoqNjc3ydampqUpJSbFZAAAA4JxI5gHAySQmJkqSgoKCbMqDgoKs2zITExMjf39/6xIaGpqrcQIAACD3kMwDwL9EVFSUkpOTrcuxY8ccHRIAAABuE8k8ADiZ4OBgSVJSUpJNeVJSknVbZjw8POTn52ezAEBBdeLECT366KMqVqyYvLy8VKtWLW3evNnRYQGA3ZDMA4CTKV++vIKDg7Vy5UprWUpKijZu3KgmTZo4MDIAyB/OnDmjZs2aqVChQlq6dKl2796td999V0WKFHF0aABgN8xmDwD50Pnz57V//37r+qFDhxQfH6+iRYuqTJkyGjZsmF599VVVrlzZ+mi6kiVLqlu3bo4LGgDyiTfffFOhoaGaNWuWtax8+fIOjAgA7I+ReQDIhzZv3qx69eqpXr16kqQRI0aoXr16GjNmjCTpueee05AhQzRw4EA1bNhQ58+f1w8//MAz5gFA0pIlS9SgQQM99NBDCgwMVL169TR9+vQs6/O0DwDOiJF5AMiHWrVqJWNMltstFotefvllvfzyy3kYFQA4h4MHD2rKlCkaMWKEXnjhBcXFxenpp5+Wu7u7IiIiMtSPiYlRdHS0AyKFI4xfvjdb9Ya3q2L3NnParr3FHjytDVft3384BiPzAAAAKFDS09N111136fXXX1e9evU0cOBADRgwQFOnTs20Pk/7AOCMSOYBAABQoISEhKh69eo2ZdWqVdPRo0czrc/TPgA4I5J5AAAAFCjNmjVTQkKCTdnevXtVtmxZB0UEAPZHMg8AAIACZfjw4dqwYYNef/117d+/X/PmzdO0adMUGRnp6NAAwG5I5gEAAFCgNGzYUIsWLdLnn3+umjVr6pVXXtGECRPUu3dvR4cGAHbDbPYAAAAocDp16qROnTo5OgwAyDWMzAMAAAAA4GRI5gEAAAAAcDIk8wAAAAAAOBmSeQAAAAAAnAzJPAAAAAAAToZkHgAAAAAAJ0MyDwAAAACAkyGZBwAAAADAyZDMAwAAAADgZEjmAQAAAABwMiTzAAAAAAA4GZJ5AAAAAACcDMk8AAAAAABOhmQeAAAAAAAnQzIPAAAAAICTIZkHAAAAAMDJkMwDAAAAAOBkSOYBAAAAAHAyJPMAAAAAADgZknkAAAAAAJwMyTwAAAAAAE6GZB4AAAAAACdDMg8AAAAAgJMhmQcAAAAAwMmQzAMAAAAA4GRI5gEAAFCgjBs3ThaLxWYJCwtzdFgAYFdujg4AAAAAsLcaNWpoxYoV1nU3N772AihYOKsBAACgwHFzc1NwcLCjwwCAXMNl9gDgpNLS0jR69GiVL19eXl5eqlixol555RUZYxwdGgA43L59+1SyZElVqFBBvXv31tGjR7Osm5qaqpSUFJsFAPI7RuYBwEm9+eabmjJliubMmaMaNWpo8+bN6tevn/z9/fX00087OjwAcJjGjRtr9uzZqlq1qk6ePKno6Gg1b95cu3btkq+vb4b6MTExio6OdkCk/07jl+/Ndt3h7arkYiR2sipGdx89fdMqG8oMvGUbQE6RzAOAk1q/fr26du2qjh07SpLKlSunzz//XJs2bXJwZADgWOHh4db/r127tho3bqyyZcvqiy++UP/+/TPUj4qK0ogRI6zrKSkpCg0NzZNYAeB2cZk9ADippk2bauXKldq7958Rju3bt+uXX36x+RJ7PS4jBfBvFRAQoCpVqmj//v2Zbvfw8JCfn5/NAgD5Hck8ADip559/Xo888ojCwsJUqFAh1atXT8OGDVPv3r0zrR8TEyN/f3/rwqgTgH+L8+fP68CBAwoJCXF0KABgNw5N5qdMmaLatWtbfwFt0qSJli5dat1+6dIlRUZGqlixYvLx8VGPHj2UlJTkwIgBIP/44osvNHfuXM2bN09bt27VnDlz9M4772jOnDmZ1o+KilJycrJ1OXbsWB5HDAB545lnntGaNWt0+PBhrV+/Xg888IBcXV3Vq1cvR4cGAHbj0HvmS5curTfeeEOVK1eWMUZz5sxR165dtW3bNtWoUUPDhw/Xd999p4ULF8rf31+DBw9W9+7dtW7dOkeGDQD5wrPPPmsdnZekWrVq6ciRI4qJiVFERESG+h4eHvLw8MjrMAEgzx0/fly9evXS6dOnVaJECd1zzz3asGGDSpQo4ejQAMBuHJrMd+7c2Wb9tdde05QpU7RhwwaVLl1aM2bM0Lx583TvvfdKkmbNmqVq1appw4YNuvvuux0RMgDkGxcvXpSLi+0FVq6urkpPT3dQRACQP8yfP9/RIQBArss3s9mnpaVp4cKFunDhgpo0aaItW7boypUratu2rbVOWFiYypQpo9jY2CyT+dTUVKWmplrXmeAJQEHVuXNnvfbaaypTpoxq1Kihbdu26b333tPjjz/u6NAAAACQyxyezO/cuVNNmjTRpUuX5OPjo0WLFql69eqKj4+Xu7u7AgICbOoHBQUpMTExy/Z4TiiAf4uJEydq9OjRGjRokE6dOqWSJUvqySef1JgxYxwdGgAAAHKZw5P5qlWrKj4+XsnJyfryyy8VERGhNWvW3HZ7PCcUwL+Fr6+vJkyYoAkTJjg6FAAAAOQxhyfz7u7uqlSpkiSpfv36iouL0/vvv6+HH35Yly9f1tmzZ21G55OSkhQcHJxle0zwBAAAAAAo6PLdc+bT09OVmpqq+vXrq1ChQlq5cqV1W0JCgo4ePaomTZo4MEIAAAAAABzrtkbmK1SooLi4OBUrVsym/OzZs7rrrrt08ODBbLUTFRWl8PBwlSlTRufOndO8efO0evVqLVu2TP7+/urfv79GjBihokWLys/PT0OGDFGTJk2YyR4AAAAA8K92W8n84cOHlZaWlqE8NTVVJ06cyHY7p06dUp8+fXTy5En5+/urdu3aWrZsmdq1aydJGj9+vFxcXNSjRw+lpqaqffv2mjx58u2EDAAAAABAgZGjZH7JkiXW/782en5NWlqaVq5cqXLlymW7vRkzZtx0u6enpyZNmqRJkyblJEwAAAAAAAq0HCXz3bp1kyRZLBZFRETYbCtUqJDKlSund999127BAQAAAACAjHKUzKenp0uSypcvr7i4OBUvXjxXggIAAAAAAFm7rXvmDx06ZO84AAAAAABANt32c+ZXrlyplStX6tSpU9YR+2tmzpx5x4EBAAAAAIDM3VYyHx0drZdfflkNGjRQSEiILBaLveMCAAAAAABZuK1kfurUqZo9e7Yee+wxe8cDAAAAAABuweV2XnT58mU1bdrU3rEAAAAAAIBsuK1k/oknntC8efPsHQsAAAAAAMiG27rM/tKlS5o2bZpWrFih2rVrq1ChQjbb33vvPbsEBwAAAAAAMrqtZH7Hjh2qW7euJGnXrl0225gMDwAAAACA3HVbyfyqVavsHQcAAAAAAMim237OPAAAWVoVk7GsdVTexwEAAFBA3VYy37p165teTv/TTz/ddkAAAAAAAODmbiuZv3a//DVXrlxRfHy8du3apYiICHvEBQAAAAAAsnBbyfz48eMzLR83bpzOnz9/RwEBAAAAAICbu63nzGfl0Ucf1cyZM+3ZJAAAAAAAuIFdk/nY2Fh5enras0kAAAAAAHCD27rMvnv37jbrxhidPHlSmzdv1ujRo+0SGAAAAAAAyNxtjcz7+/vbLEWLFlWrVq30/fffa+zYsfaOEQAAALhtb7zxhiwWi4YNG+boUADAbm5rZH7WrFn2jgMAAACwu7i4OH300UeqXbu2o0MBALu6o3vmt2zZos8++0yfffaZtm3bZq+YAAAAgDt2/vx59e7dW9OnT1eRIkUcHQ4A2NVtjcyfOnVKjzzyiFavXq2AgABJ0tmzZ9W6dWvNnz9fJUqUsGeMAAAAQI5FRkaqY8eOatu2rV599dUs66Wmpio1NdW6npKSkhfhAcAdua1kfsiQITp37px+/fVXVatWTZK0e/duRURE6Omnn9bnn39u1yABAACAnJg/f762bt2quLi4W9aNiYlRdHR0HkSF/OTuo9Nuuj12Rh4Fks9Yj8uqYllXah2VN8Hgpm7rMvsffvhBkydPtibyklS9enVNmjRJS5cutVtwAAAAQE4dO3ZMQ4cO1dy5c7P12OSoqCglJydbl2PHjuVBlABwZ25rZD49PV2FChXKUF6oUCGlp6ffcVAAAADA7dqyZYtOnTqlu+66y1qWlpamtWvX6sMPP1RqaqpcXV2t2zw8POTh4eGIUAHgtt3WyPy9996roUOH6vfff7eWnThxQsOHD1ebNm3sFhwAAACQU23atNHOnTsVHx9vXRo0aKDevXsrPj7eJpEHAGd1WyPzH374obp06aJy5copNDRU0j+XM9WsWVOfffaZXQMEAAAAcsLX11c1a9a0KfP29laxYsUylAOAs7qtZD40NFRbt27VihUr9Ntvv0mSqlWrprZt29o1OAAAAAAAkFGOkvmffvpJgwcP1oYNG+Tn56d27dqpXbt2kqTk5GTVqFFDU6dOVfPmzXMlWAAAAOB2rF692tEhAIBd5eie+QkTJmjAgAHy8/PLsM3f319PPvmk3nvvPbsFBwC4uRMnTujRRx9VsWLF5OXlpVq1amnz5s2ODgsAAAC5LEfJ/Pbt29WhQ4cst993333asmXLHQcFALi1M2fOqFmzZipUqJCWLl2q3bt3691331WRIkUcHRoAAAByWY4us09KSsr0kXTWxtzc9Mcff9xxUACAW3vzzTcVGhqqWbNmWcvKly/vwIgAAACQV3I0Ml+qVCnt2rUry+07duxQSEjIHQcFALi1JUuWqEGDBnrooYcUGBioevXqafr06VnWT01NVUpKis0CAAAA55Sjkfn7779fo0ePVocOHeTp6Wmz7e+//9bYsWPVqVMnuwYIAMjcwYMHNWXKFI0YMUIvvPCC4uLi9PTTT8vd3V0REREZ6sfExCg6OtoBkRYM45fvzfFrhrerkguRAAAA5DCZf+mll/T111+rSpUqGjx4sKpWrSpJ+u233zRp0iSlpaXpxRdfzJVAAQC20tPT1aBBA73++uuSpHr16mnXrl2aOnVqpsl8VFSURowYYV1PSUlRaGhonsULAAAA+8lRMh8UFKT169frqaeeUlRUlIwxkiSLxaL27dtr0qRJCgoKypVAAQC2QkJCVL16dZuyatWq6auvvsq0voeHhzw8PPIiNAAAAOSyHCXzklS2bFl9//33OnPmjPbv3y9jjCpXrszsyQCQx5o1a6aEhASbsr1796ps2bIOiggAAAB5JcfJ/DVFihRRw4YN7RkLACAHhg8frqZNm+r1119Xz549tWnTJk2bNk3Tpk1zdGgAAADIZTmazR4AkH80bNhQixYt0ueff66aNWvqlVde0YQJE9S7d29HhwYAAIBcdtsj8wAAx+vUqRNPEQEAAPgXYmQeAAAAAAAnQzIPAAAAAICTIZkHAAAAAMDJkMwDAAAAAOBkSOYBAAAAAHAyJPMAAAAAADgZknkAAAAAAJyMQ5P5mJgYNWzYUL6+vgoMDFS3bt2UkJBgU+fSpUuKjIxUsWLF5OPjox49eigpKclBEQMAAAAA4HgOTebXrFmjyMhIbdiwQcuXL9eVK1d033336cKFC9Y6w4cP1//+9z8tXLhQa9as0e+//67u3bs7MGoAAAAAABzLzZE7/+GHH2zWZ8+ercDAQG3ZskUtWrRQcnKyZsyYoXnz5unee++VJM2aNUvVqlXThg0bdPfddzsibAAAAAAAHCpf3TOfnJwsSSpatKgkacuWLbpy5Yratm1rrRMWFqYyZcooNjY20zZSU1OVkpJiswAAAAAAUJDkm2Q+PT1dw4YNU7NmzVSzZk1JUmJiotzd3RUQEGBTNygoSImJiZm2ExMTI39/f+sSGhqa26EDAAAAAJCn8k0yHxkZqV27dmn+/Pl31E5UVJSSk5Oty7Fjx+wUIQAAAAAA+YND75m/ZvDgwfr222+1du1alS5d2loeHBysy5cv6+zZszaj80lJSQoODs60LQ8PD3l4eOR2yAAAAAAAOIxDR+aNMRo8eLAWLVqkn376SeXLl7fZXr9+fRUqVEgrV660liUkJOjo0aNq0qRJXocLAAAAAEC+4NBkPjIyUp999pnmzZsnX19fJSYmKjExUX///bckyd/fX/3799eIESO0atUqbdmyRf369VOTJk2YyR4AAACZmjJlimrXri0/Pz/5+fmpSZMmWrp0qaPDAgC7cuhl9lOmTJEktWrVyqZ81qxZ6tu3ryRp/PjxcnFxUY8ePZSamqr27dtr8uTJeRwpACAvjV++12b97qPTMtTZUGagXfeRHbkRBwD7K126tN544w1VrlxZxhjNmTNHXbt21bZt21SjRg1HhwcAduHQZN4Yc8s6np6emjRpkiZNmpQHEQEAAMDZde7c2Wb9tdde05QpU7RhwwaSeQAFRr6YAA8AAADIDWlpaVq4cKEuXLiQ5ZxLqampSk1Nta6npKTkVXgAcNtI5gEAAFDg7Ny5U02aNNGlS5fk4+OjRYsWqXr16pnWjYmJUXR0dB5HWLDczq1LBWn/t3L9bVqxM7L3miYViuVSNCgo8s1z5gEAAAB7qVq1quLj47Vx40Y99dRTioiI0O7duzOtGxUVpeTkZOty7NixPI4WAHKOkXkAAAAUOO7u7qpUqZKkfx53HBcXp/fff18fffRRhroeHh7y8PDI6xAB4I4wMg8AAIACLz093ea+eABwdozMAwAAoECJiopSeHi4ypQpo3PnzmnevHlavXq1li1b5ujQAMBuSOYBAABQoJw6dUp9+vTRyZMn5e/vr9q1a2vZsmVq166do0MDALshmQcAAECBMmNGNqcLBwAnxj3zAAAAAAA4GZJ5AAAAAACcDMk8AAAAAABOhmQeAAAAAAAnQzIPAAAAAICTIZkHAAAAAMDJkMwDAAAAAOBkSOYBAAAAAHAyJPMAUAC88cYbslgsGjZsmKNDAQAAQB4gmQcAJxcXF6ePPvpItWvXdnQoAAAAyCMk8wDgxM6fP6/evXtr+vTpKlKkiKPDAQAAQB4hmQcAJxYZGamOHTuqbdu2t6ybmpqqlJQUmwUAAADOyc3RAQAAbs/8+fO1detWxcXFZat+TEyMoqOjczmqzMUePK0NV/c6ZN+ONH55zvo8vF2VXIoEAAAUNIzMA4ATOnbsmIYOHaq5c+fK09MzW6+JiopScnKydTl27FguRwkAAIDcwsg8ADihLVu26NSpU7rrrrusZWlpaVq7dq0+/PBDpaamytXV1eY1Hh4e8vDwyOtQAQAAkAtI5gHACbVp00Y7d+60KevXr5/CwsI0atSoDIk8AAAAChaSeQBwQr6+vqpZs6ZNmbe3t4oVK5ahHAAAAAUP98wDAAAAAOBkGJkHgAJi9erVjg4BAAAAeYSReQAAAAAAnAzJPAAAAAAAToZkHgAAAAAAJ0MyDwAAAACAkyGZBwAAAADAyZDMAwAAAADgZEjmAQAAUKDExMSoYcOG8vX1VWBgoLp166aEhARHhwUAdkUyDwAAgAJlzZo1ioyM1IYNG7R8+XJduXJF9913ny5cuODo0ADAbtwcHQAAAABgTz/88IPN+uzZsxUYGKgtW7aoRYsWDooKAOyLZB4AAAAFWnJysiSpaNGimW5PTU1VamqqdT0lJSVP4gKAO0EyDwAAgAIrPT1dw4YNU7NmzVSzZs1M68TExCg6OvqO9zV++d47buNGw9tVsXubziQ3jmlBFHvwdJ62ueGq7fvyb/+cOgr3zAMAAKDAioyM1K5duzR//vws60RFRSk5Odm6HDt2LA8jBIDbw8g8AAAACqTBgwfr22+/1dq1a1W6dOks63l4eMjDwyMPIwOAO0cyDwAAgALFGKMhQ4Zo0aJFWr16tcqXL+/okADA7kjmAQAAUKBERkZq3rx5+uabb+Tr66vExERJkr+/v7y8vBwcHQDYB/fMAwAAoECZMmWKkpOT1apVK4WEhFiXBQsWODo0ALAbRuYBAHdmVUy2qt19dFqGsg1lBmarXnZldx/23CdwTU5n3Wb259xjjHF0CACQ6xiZBwAAAADAyZDMAwAAAADgZEjmAQAAAABwMiTzAAAAAAA4GYcm82vXrlXnzp1VsmRJWSwWLV682Ga7MUZjxoxRSEiIvLy81LZtW+3bt88xwQIAAAAAkE84NJm/cOGC6tSpo0mTJmW6/a233tIHH3ygqVOnauPGjfL29lb79u116dKlPI4UAAAAAID8w6GPpgsPD1d4eHim24wxmjBhgl566SV17dpVkvTJJ58oKChIixcv1iOPPJKXoQIAAAAAkG/k23vmDx06pMTERLVt29Za5u/vr8aNGys2NjbL16WmpiolJcVmAQAAAACgIMm3yXxiYqIkKSgoyKY8KCjIui0zMTEx8vf3ty6hoaG5GicAAAAAAHkt3ybztysqKkrJycnW5dixY44OCQAAAAAAu8q3yXxwcLAkKSkpyaY8KSnJui0zHh4e8vPzs1kAAAAAAChI8m0yX758eQUHB2vlypXWspSUFG3cuFFNmjRxYGQAAAAAADiWQ2ezP3/+vPbv329dP3TokOLj41W0aFGVKVNGw4YN06uvvqrKlSurfPnyGj16tEqWLKlu3bo5LmgAAAAAABzMocn85s2b1bp1a+v6iBEjJEkRERGaPXu2nnvuOV24cEEDBw7U2bNndc899+iHH36Qp6eno0IGAAAAAMDhHJrMt2rVSsaYLLdbLBa9/PLLevnll/MwKgAAAAAA8rd8e888AAAAAADIHMk8AAAAAABOhmQeAJxUTEyMGjZsKF9fXwUGBqpbt25KSEhwdFgAAADIAyTzAOCk1qxZo8jISG3YsEHLly/XlStXdN999+nChQuODg0AAAC5zKET4AEAbt8PP/xgsz579mwFBgZqy5YtatGihYOiAgAAQF5gZB4ACojk5GRJUtGiRR0cCQAAAHIbI/MAUACkp6dr2LBhatasmWrWrJlpndTUVKWmplrXU1JS8io8AAAA2BnJPAAUAJGRkdq1a5d++eWXLOvExMQoOjo6D6O6tbuPTnP6fWbW3oYyA2/vtauKSa2jbiiLyfjCG+vgX2H88r25vo/h7ark+j4AAPbBZfYA4OQGDx6sb7/9VqtWrVLp0qWzrBcVFaXk5GTrcuzYsTyMEgAAAPbEyDwAOCljjIYMGaJFixZp9erVKl++/E3re3h4yMPDI4+iAwAAQG4imQcAJxUZGal58+bpm2++ka+vrxITEyVJ/v7+8vLycnB0AAAAyE1cZg8ATmrKlClKTk5Wq1atFBISYl0WLFjg6NAAwKHWrl2rzp07q2TJkrJYLFq8eLGjQwIAu2NkHgCclDHG0SEAQL504cIF1alTR48//ri6d+/u6HAAIFeQzAMAAKBACQ8PV3h4uKPDAIBcRTIPAACAf7XU1FSlpqZa11NSUhwYDQBkD8k8AAAA/tViYmIUHR3t6DDypfHL99q1vbuPTrtlnQ1lBtqlHWcXe/B0rrRrj2N3YxuxM+64yQyaVChmv8ZaR926zqqYO28jjzEBHgAAAP7VoqKilJycbF2OHTvm6JAA4JYYmQeQb9zOr//D21XJhUgAAP8mHh4e8vDwcHQYAJAjjMwDAAAAAOBkGJkHAABAgXL+/Hnt37/fun7o0CHFx8eraNGiKlOmjAMjAwD7IZkHAABAgbJ582a1bt3auj5ixAhJUkREhGbPnu2gqADAvkjmAQAAUKC0atVKxhhHhwEAuYp75gEAAAAAcDIk8wAAAAAAOBmSeQAAAAAAnAzJPAAAAAAAToZkHgAAAAAAJ0MyDwAAAACAkyGZBwAAAADAyfCceQBAzqyKUezB046OQncfnWbXevZ0u/uMPXhaG67uvaGtjMf6xjo5Mbxdldt+rTMbv/z2j1luyY8xAQCcByPzAAAAAAA4GZJ5AAAAAACcDMk8AAAAAABOhmQeAAAAAAAnwwR4AHIFEzsBAAAAuYeReQAAAAAAnAzJPAAAAAAAToZkHgAAAAAAJ0MyDwAAAACAkyGZBwAAAADAyZDMAwAAAADgZEjmAQAAAABwMiTzAAAAAAA4GZJ5AAAAAACcDMk8AAAAAABOhmQeAAAAAAAn4+boAICCZvzyvTl+zfB2VXIhkszl9/gAAAAA3Boj8wAAAAAAOBmnSOYnTZqkcuXKydPTU40bN9amTZscHRIA5BucIwEgc5wfARRk+T6ZX7BggUaMGKGxY8dq69atqlOnjtq3b69Tp045OjQAcDjOkQCQOc6PAAq6fJ/Mv/feexowYID69eun6tWra+rUqSpcuLBmzpzp6NAAwOE4RwJA5jg/Aijo8vUEeJcvX9aWLVsUFRVlLXNxcVHbtm0VGxub6WtSU1OVmppqXU9OTpYkpaSk5G6wt+nC36m3rnSD/NoX/OPShfM5fk1evqd5Fd/t7Od25Paxu9a+MSZX93M7cnqOtNv58cKl2zp3IXtu/NvJ7Fjfyd/Xv/XfkLw6Jzm7nH4+8us50lHnx9z4nDn6b9befcrOvx/Z2Sf/DhV8KRcu2bGxbPwd3Wp/+fH8aPKxEydOGElm/fr1NuXPPvusadSoUaavGTt2rJHEwsLCYtfl2LFjeXHay5GcniM5P7KwsOTWkt/OkZwfWVhY8suSm+fHfD0yfzuioqI0YsQI63p6err++usvFStWTBaL5ZavT0lJUWhoqI4dOyY/P7/cDDVX0Y/8pSD0oyD0Qcp5P4wxOnfunEqWLJkH0eWuOz0/XlNQPgu5iWN0axyjW3OGY1RQzpH2Oj/mR87wObpdBblvEv1zZtf6tnv37lw9P+brZL548eJydXVVUlKSTXlSUpKCg4MzfY2Hh4c8PDxsygICAnK8bz8/vwLxoaIf+UtB6EdB6IOUs374+/vncjS3J6fnSHudH68pKJ+F3MQxujWO0a3l92OUH8+Rjj4/5kf5/XN0Jwpy3yT658xKlSolF5fcm6YuX0+A5+7urvr162vlypXWsvT0dK1cuVJNmjRxYGQA4HicIwEgc5wfAfwb5OuReUkaMWKEIiIi1KBBAzVq1EgTJkzQhQsX1K9fP0eHBgAOxzkSADLH+RFAQZfvk/mHH35Yf/zxh8aMGaPExETVrVtXP/zwg4KCgnJlfx4eHho7dmyGS62cDf3IXwpCPwpCH6SC049r8vocKRW8Y5gbOEa3xjG6NY7RnXHE+TE/Ksifo4LcN4n+ObO86pvFmHz2LBEAAAAAAHBT+fqeeQAAAAAAkBHJPAAAAAAAToZkHgAAAAAAJ0MyDwAAAACAk3H6ZH7SpEkqV66cPD091bhxY23atOmm9RcuXKiwsDB5enqqVq1a+v777222G2M0ZswYhYSEyMvLS23bttW+ffts6vz111/q3bu3/Pz8FBAQoP79++v8+fPW7QkJCWrdurWCgoLk6empChUq6KWXXtKVK1ecqh/X279/v3x9fRUQEHDTuPJjPw4fPiyLxZJh2bBhg9P04Vo777zzjqpUqSIPDw+VKlVKr732WpZx5cd+jBs3LtP3wtvb26n6IUnLli3T3XffLV9fX5UoUUI9evTQ4cOHbxqbo9jzGF65ckWjRo1SrVq15O3trZIlS6pPnz76/fffbdqw999lbnPEMXrttdfUtGlTFS5cOMtz69GjR9WxY0cVLlxYgYGBevbZZ3X16tU77u/tyK/HKLPP0fz58++4v7cjr4/R4cOH1b9/f5UvX15eXl6qWLGixo4dq8uXL9vsZ8eOHWrevLk8PT0VGhqqt956y74dR57K6efsmvnz58tisahbt2425ePGjVNYWJi8vb1VpEgRtW3bVhs3bsyFyLPH3v273n//+19ZLBZNmDDBPsHmkL371rdv3wznvw4dOuRC5NmTG+/dnj171KVLF/n7+8vb21sNGzbU0aNH7Rx59ti7f5n9+2WxWPT2229nPyjjxObPn2/c3d3NzJkzza+//moGDBhgAgICTFJSUqb1161bZ1xdXc1bb71ldu/ebV566SVTqFAhs3PnTmudN954w/j7+5vFixeb7du3my5dupjy5cubv//+21qnQ4cOpk6dOmbDhg3m559/NpUqVTK9evWybj9w4ICZOXOmiY+PN4cPHzbffPONCQwMNFFRUU7Vj2suX75sGjRoYMLDw42/v3/mb0Y+7sehQ4eMJLNixQpz8uRJ63L58mWn6YMxxgwZMsRUrVrVfPPNN+bgwYNm8+bN5scff3Sq9+LcuXM278HJkydN9erVTUREhFP14+DBg8bDw8NERUWZ/fv3my1btpgWLVqYevXqZRqXI9n7GJ49e9a0bdvWLFiwwPz2228mNjbWNGrUyNSvX9+mHXv+XeY2Rx2jMWPGmPfee8+MGDEi03Pr1atXTc2aNU3btm3Ntm3bzPfff2+KFy+e5b8luSm/HiNjjJFkZs2aZfM5uv7vOa844hgtXbrU9O3b1yxbtswcOHDA+n1j5MiR1jrJyckmKCjI9O7d2+zatct8/vnnxsvLy3z00Ue5e0CQK3L6Obvm0KFDplSpUqZ58+ama9euNtvmzp1rli9fbg4cOGB27dpl+vfvb/z8/MypU6dysSeZy43+XfP111+bOnXqmJIlS5rx48fbP/hbyI2+RUREmA4dOtic//76669c7EXWcqN/+/fvN0WLFjXPPvus2bp1q9m/f7/55ptvbtlmbsiN/t34nXjmzJnGYrGYAwcOZDsup07mGzVqZCIjI63raWlppmTJkiYmJibT+j179jQdO3a0KWvcuLF58sknjTHGpKenm+DgYPP2229bt589e9Z4eHiYzz//3BhjzO7du40kExcXZ62zdOlSY7FYzIkTJ7KMdfjw4eaee+5xyn4899xz5tFHHzWzZs26aTKfX/txLWnYtm1blrHn9z7s3r3buLm5md9+++2WfcjP/bhRfHy8kWTWrl3rVP1YuHChcXNzM2lpadY6S5YsMRaLxSHJ6M3Y+xhmZtOmTUaSOXLkiDHG/n+Xuc0Rx+h6WZ1bv//+e+Pi4mISExOtZVOmTDF+fn4mNTX1Vt2yq/x6jIz5J5lftGjRrTuRyxx9jK556623TPny5a3rkydPNkWKFLH5zIwaNcpUrVr1ln1C/pPTz5kx//ww2LRpU/Pxxx+biIiILJPda5KTk60/tua13Orf8ePHTalSpcyuXbtM2bJlHZLM50bfsvN+5pXc6N/DDz9sHn300dwKOUfy4m+va9eu5t57781RXE57mf3ly5e1ZcsWtW3b1lrm4uKitm3bKjY2NtPXxMbG2tSXpPbt21vrHzp0SImJiTZ1/P391bhxY2ud2NhYBQQEqEGDBtY6bdu2lYuLS5aXJO3fv18//PCDWrZs6XT9+Omnn7Rw4UJNmjQp01icpR+S1KVLFwUGBuqee+7RkiVLnKoP//vf/1ShQgV9++23Kl++vMqVK6cnnnhCf/31l1P140Yff/yxqlSpoubNmztVP+rXry8XFxfNmjVLaWlpSk5O1qeffqq2bduqUKFCmcbmCLlxDDOTnJwsi8VivQzann+Xuc1Rxyg7YmNjVatWLQUFBdnsJyUlRb/++mu227lT+fkYXRMZGanixYurUaNGmjlzpowxOW7jTuSnY5ScnKyiRYva7KdFixZyd3e32U9CQoLOnDlzq64hH7mdz5kkvfzyywoMDFT//v2ztY9p06bJ399fderUsUvc2ZVb/UtPT9djjz2mZ599VjVq1LB73NmRm+/d6tWrFRgYqKpVq+qpp57S6dOn7Rp7duRG/9LT0/Xdd9+pSpUqat++vQIDA9W4cWMtXrw4N7pwU3nxt5eUlKTvvvsuW3Wv57TJ/J9//qm0tDSbLzmSFBQUpMTExExfk5iYeNP61/57qzqBgYE2293c3FS0aNEM+23atKk8PT1VuXJlNW/eXC+//LJT9eP06dPq27evZs+eLT8/v0xjcYZ++Pj46N1339XChQv13Xff6Z577lG3bt0yJA75uQ8HDx7UkSNHtHDhQn3yySeaPXu2tmzZogcffDBDTPm5H9e7dOmS5s6dm+VJKz/3o3z58vrxxx/1wgsvyMPDQwEBATp+/Li++OKLTONylNw4hje6dOmSRo0apV69elnPE/b8u8xtjjpG2ZHVfq5tyyv5+RhJ/3xZ+uKLL7R8+XL16NFDgwYN0sSJE3PUxp3KL8do//79mjhxop588slb7ufaNjiP2/mc/fLLL5oxY4amT59+07a//fZb+fj4yNPTU+PHj9fy5ctVvHhxu8WeHbnVvzfffFNubm56+umn7RpvTuRW3zp06KBPPvlEK1eu1Jtvvqk1a9YoPDxcaWlpdo3/VnKjf6dOndL58+f1xhtvqEOHDvrxxx/1wAMPqHv37lqzZo3d+3Azufm3d82cOXPk6+ur7t275yg2txzVRo4sWLBA586d0/bt2/Xss8/qnXfe0XPPPefosLJtwIAB+s9//qMWLVo4OpQ7Urx4cY0YMcK63rBhQ/3+++96++231aVLFwdGln3p6elKTU3VJ598oipVqkiSZsyYofr16yshIUFVq1Z1cIQ5t2jRIp07d04RERGODiXHEhMTNWDAAEVERKhXr146d+6cxowZowcffFDLly+XxWJxdIh54sqVK+rZs6eMMZoyZUqOXlsQ/i6z406O0b/FnR6j0aNHW/+/Xr16unDhgt5++22HfnG3t+wcoxMnTqhDhw566KGHNGDAgDyOEPnRuXPn9Nhjj2n69Om3TMxbt26t+Ph4/fnnn5o+fbp69uypjRs3ZvhhNj/JTv+2bNmi999/X1u3bnWqf5uz+9498sgj1v+vVauWateurYoVK2r16tVq06ZNXoR6W7LTv/T0dElS165dNXz4cElS3bp1tX79ek2dOjXTK57zi5z87V0zc+ZM9e7dW56enjnal9Mm88WLF5erq6uSkpJsypOSkhQcHJzpa4KDg29a/9p/k5KSFBISYlOnbt261jqnTp2yaePq1av666+/Muw3NDRUklS9enWlpaVp4MCBGjlypFxdXZ2iHz/99JOWLFmid955R9I/s4Cnp6fLzc1N06ZN0+OPP+4U/chM48aNtXz5cpuy/NyHkJAQubm5WRN5SapWrZqkf2a7vj6Zz8/9uN7HH3+sTp06ZfiV0xn6MWnSJPn7+9vMCP3ZZ58pNDRUGzdu1N13351pfHktN47hNdeSiyNHjuinn36yGSm0599lbnPUMcqO4ODgDDPlXtvvzY6jveXnY5SZxo0b65VXXlFqaqo8PDzuuL3scPQx+v3339W6dWs1bdpU06ZNy9Z+rm2D88jp5+zAgQM6fPiwOnfubC27liC5ubkpISFBFStWlCR5e3urUqVKqlSpku6++25VrlxZM2bMUFRUVC72yFZu9O/nn3/WqVOnVKZMGWudtLQ0jRw5UhMmTMizp9Dk5nt3vQoVKqh48eLav39/nibzudG/0NBQubm5qXr16javrVatmn755Zdc6EXWcvv9+/nnn5WQkKAFCxbkODanvcze3d1d9evX18qVK61l6enpWrlypZo0aZLpa5o0aWJTX5KWL19urV++fHkFBwfb1ElJSdHGjRutdZo0aaKzZ89qy5Yt1jo//fST0tPT1bhx4yzjTU9P15UrV6xvpDP0IzY2VvHx8dbl5Zdflq+vr+Lj4/XAAw84TT8yEx8fb5PM5fc+NGvWTFevXtWBAwesdfbu3StJKlu2rNP045pDhw5p1apVN70vKD/34+LFi3JxsT19XvuR7sa/cUfKjWMo/V9ysW/fPq1YsULFihXL0Ia9/i5zm6OOUXY0adJEO3futPlhZPny5fLz88vw5SY35edjlJn4+HgVKVIkzxJ5ybHH6MSJE2rVqpXq16+vWbNmZTg3NWnSRGvXrrV5PO7y5ctVtWpVFSlS5Lb6C8fI6ecsLCxMO3futPku16VLF+so/LVBp8xcuyIwL+VG/x577DHt2LHDpk7JkiX17LPPatmyZU7dt8wcP35cp0+fzvf/lmanf+7u7mrYsKESEhJsXrt3794M331zW26/f9eutr2teSpyNF1ePjN//nzj4eFhZs+ebXbv3m0GDhxoAgICrDP/PvbYY+b555+31l+3bp1xc3Mz77zzjtmzZ48ZO3Zspo+tCggIMN98843ZsWOH6dq1a6aPrapXr57ZuHGj+eWXX0zlypVtHrn02WefmQULFpjdu3ebAwcOmAULFpiSJUua3r17O1U/bnSr2ezzaz9mz55t5s2bZ/bs2WP27NljXnvtNePi4mJmzpzpNH1IS0szd911l2nRooXZunWr2bx5s2ncuLFp166dU70X17z00kumZMmS5urVq5nGn9/7sXLlSmOxWEx0dLTZu3ev2bJli2nfvr0pW7asuXjx4k37lNfsfQwvX75sunTpYkqXLm3i4+NtHqly/WzZ9vy7zG2OOkZHjhwx27ZtM9HR0cbHx8ds27bNbNu2zZw7d84Y83+PprvvvvtMfHy8+eGHH0yJEiUc9mi6/HiMlixZYqZPn2527txp9u3bZyZPnmwKFy5sxowZk4dH5x+OOEbHjx83lSpVMm3atDHHjx+3qXPN2bNnTVBQkHnsscfMrl27zPz5803hwoV5NJ2Tyunn7EY3zqh9/vx5ExUVZWJjY83hw4fN5s2bTb9+/YyHh4fZtWtXbncnA3v3LzOOms3e3n07d+6ceeaZZ0xsbKw5dOiQWbFihbnrrrtM5cqVzaVLl3K7Oxnkxnv39ddfm0KFCplp06aZffv2mYkTJxpXV1fz888/52ZXMpVbn83k5GRTuHBhM2XKlNuKy6mTeWOMmThxoilTpoxxd3c3jRo1Mhs2bLBua9myZYbnV3/xxRemSpUqxt3d3dSoUcN89913NtvT09PN6NGjTVBQkPHw8DBt2rQxCQkJNnVOnz5tevXqZXx8fIyfn5/p16+f9YuFMf+82XfddZfx8fEx3t7epnr16ub111+/6XNv82M/bnSrZD6/9mP27NmmWrVqpnDhwsbPz880atTILFy40Kn6YIwxJ06cMN27dzc+Pj4mKCjI9O3b15w+fdrp+pGWlmZKly5tXnjhhSxjd4Z+fP7556ZevXrG29vblChRwnTp0sXs2bMnW33Ka/Y8htceKZfZsmrVKms9e/9d5jZHHKOIiIhb1jl8+LAJDw83Xl5epnjx4mbkyJHmypUruXUYbio/HqOlS5eaunXrWv+9rVOnjpk6darNYyPzUl4fo1mzZmVZ53rbt28399xzj/Hw8DClSpUyb7zxRq4dA+S+nH7OrndjQvH333+bBx54wJQsWdK4u7ubkJAQ06VLF7Np06Zc7MHN2bN/mXFUMm+Mfft28eJFc99995kSJUqYQoUKmbJly5oBAwbYPM40r+XGezdjxgxTqVIl4+npaerUqWMWL16cC5FnT27076OPPjJeXl7m7NmztxWTxZg8fn4LAAAAAAC4I057zzwAAAAAAP9WJPMAAAAAADgZknkAAAAAAJwMyTwAAAAAAE6GZB4AAAAAACdDMg8AAAAAgJMhmQcAAAAAwMmQzMNplCtXThMmTMh2/dWrV8tisejs2bO5FhMAAADyVqtWrTRs2DDrena+I1osFi1evPiO922vdgB7IJmH3Vkslpsu48aNu6124+LiNHDgwGzXb9q0qU6ePCl/f//b2l928aMBAGfQt29fdevWzdFhAPgX69y5szp06JDptp9//lkWi0U7duzIcbs5/Y6YHePGjVPdunUzlJ88eVLh4eF23deNZs+erYCAgFzdBwoGN0cHgILn5MmT1v9fsGCBxowZo4SEBGuZj4+P9f+NMUpLS5Ob260/iiVKlMhRHO7u7goODs7RawAAAJA7+vfvrx49euj48eMqXbq0zbZZs2apQYMGql27do7bzel3xDvBd0vkJ4zMw+6Cg4Oti7+/vywWi3X9t99+k6+vr5YuXar69evLw8NDv/zyiw4cOKCuXbsqKChIPj4+atiwoVasWGHT7o2XUFksFn388cd64IEHVLhwYVWuXFlLliyxbr9xxPzar5zLli1TtWrV5OPjow4dOtj8+HD16lU9/fTTCggIULFixTRq1ChFRETc0WjWmTNn1KdPHxUpUkSFCxdWeHi49u3bZ91+5MgRde7cWUWKFJG3t7dq1Kih77//3vra3r17q0SJEvLy8lLlypU1a9as244FADKzZs0aNWrUSB4eHgoJCdHzzz+vq1evWrd/+eWXqlWrlry8vFSsWDG1bdtWFy5ckPTPubZRo0by9vZWQECAmjVrpiNHjjiqKwDysU6dOqlEiRKaPXu2Tfn58+e1cOFC9e/fX6dPn1avXr1UqlQpFS5cWLVq1dLnn39+03Zv/I64b98+tWjRQp6enqpevbqWL1+e4TWjRo1SlSpVVLhwYVWoUEGjR4/WlStXJP3znTE6Olrbt2+3Xll6LeYbL7PfuXOn7r33Xuv5ceDAgTp//rx1+7Wrot555x2FhISoWLFiioyMtO7rdhw9elRdu3aVj4+P/Pz81LNnTyUlJVm3b9++Xa1bt5avr6/8/PxUv359bd68WdLNv3fC+ZDMwyGef/55vfHGG9qzZ49q166t8+fP6/7779fKlSu1bds2dejQQZ07d9bRo0dv2k50dLR69uypHTt26P7771fv3r31119/ZVn/4sWLeuedd/Tpp59q7dq1Onr0qJ555hnr9jfffFNz587VrFmztG7dOqWkpNzxfVF9+/bV5s2btWTJEsXGxsoYo/vvv996Eo+MjFRqaqrWrl2rnTt36s0337RevTB69Gjt3r1bS5cu1Z49ezRlyhQVL178juIBgOudOHFC999/vxo2bKjt27drypQpmjFjhl599VVJ/1xt1atXLz3++OPas2ePVq9ere7du8sYo6tXr6pbt25q2bKlduzYodjYWA0cOFAWi8XBvQKQH7m5ualPnz6aPXu2jDHW8oULFyotLU29evXSpUuXVL9+fX333XfatWuXBg4cqMcee0ybNm3K1j7S09PVvXt3ubu7a+PGjZo6dapGjRqVoZ6vr69mz56t3bt36/3339f06dM1fvx4SdLDDz+skSNHqkaNGjp58qROnjyphx9+OEMbFy5cUPv27VWkSBHFxcVp4cKFWrFihQYPHmxTb9WqVTpw4IBWrVqlOXPmaPbs2Rl+0Miu9PR0de3aVX/99ZfWrFmj5cuX6+DBgzbx9e7dW6VLl1ZcXJy2bNmi559/XoUKFZJ08++dcEIGyEWzZs0y/v7+1vVVq1YZSWbx4sW3fG2NGjXMxIkTretly5Y148ePt65LMi+99JJ1/fz580aSWbp0qc2+zpw5Y41Fktm/f7/1NZMmTTJBQUHW9aCgIPP2229b169evWrKlCljunbtmmWcN+7nenv37jWSzLp166xlf/75p/Hy8jJffPGFMcaYWrVqmXHjxmXadufOnU2/fv2y3DcAZFdERESm57IXXnjBVK1a1aSnp1vLJk2aZHx8fExaWprZsmWLkWQOHz6c4bWnT582kszq1atzM3QABciePXuMJLNq1SprWfPmzc2jjz6a5Ws6duxoRo4caV1v2bKlGTp0qHX9+u+Iy5YtM25ububEiRPW7UuXLjWSzKJFi7Lcx9tvv23q169vXR87dqypU6dOhnrXtzNt2jRTpEgRc/78eev27777zri4uJjExERjzD/n3rJly5qrV69a6zz00EPm4YcfzjKWG78/X+/HH380rq6u5ujRo9ayX3/91UgymzZtMsYY4+vra2bPnp3p62/2vRPOh5F5OESDBg1s1s+fP69nnnlG1apVU0BAgHx8fLRnz55bjsxff1+Vt7e3/Pz8dOrUqSzrFy5cWBUrVrSuh4SEWOsnJycrKSlJjRo1sm53dXVV/fr1c9S36+3Zs0dubm5q3LixtaxYsWKqWrWq9uzZI0l6+umn9eqrr6pZs2YaO3aszcQvTz31lObPn6+6devqueee0/r16287FgDIzJ49e9SkSROb0fRmzZrp/PnzOn78uOrUqaM2bdqoVq1aeuihhzR9+nSdOXNGklS0aFH17dtX7du3V+fOnfX+++/b3LoEADcKCwtT06ZNNXPmTEnS/v379fPPP6t///6SpLS0NL3yyiuqVauWihYtKh8fHy1btuyW3wmv2bNnj0JDQ1WyZElrWZMmTTLUW7BggZo1a6bg4GD5+PjopZdeyvY+rt9XnTp15O3tbS1r1qyZ0tPTbeaLqlGjhlxdXa3r13//zKlr/QsNDbWWVa9eXQEBAdbvliNGjNATTzyhtm3b6o033tCBAwesdW/2vRPOh2QeDnH9SU+SnnnmGS1atEivv/66fv75Z8XHx6tWrVq6fPnyTdu5dsnQNRaLRenp6Tmqb667zMsRnnjiCR08eFCPPfaYdu7cqQYNGmjixImSpPDwcB05ckTDhw/X77//rjZt2tjcFgAAuc3V1VXLly/X0qVLVb16dU2cOFFVq1bVoUOHJP0zaVVsbKyaNm2qBQsWqEqVKtqwYYODowaQn/Xv319fffWVzp07p1mzZqlixYpq2bKlJOntt9/W+++/r1GjRmnVqlWKj49X+/btb/mdMCdiY2PVu3dv3X///fr222+1bds2vfjii3bdx/Vy+n31To0bN06//vqrOnbsqJ9++knVq1fXokWLJN38eyecD8k88oV169apb9++euCBB1SrVi0FBwfr8OHDeRqDv7+/goKCFBcXZy1LS0vT1q1bb7vNatWq6erVq9q4caO17PTp00pISFD16tWtZaGhofrvf/+rr7/+WiNHjtT06dOt20qUKKGIiAh99tlnmjBhgqZNm3bb8QDAjapVq2adz+OadevWydfX1zrbtMViUbNmzRQdHa1t27bJ3d3d+sVQkurVq6eoqCitX79eNWvW1Lx58/K8HwCcR8+ePeXi4qJ58+bpk08+0eOPP269OmjdunXq2rWrHn30UdWpU0cVKlTQ3r17s912tWrVdOzYMZurhG78gXH9+vUqW7asXnzxRTVo0ECVK1fOMHGnu7u70tLSbrmv7du3WycEvRa/i4uLqlatmu2Yc+Ja/44dO2Yt2717t86ePWvz3bJKlSoaPny4fvzxR3Xv3t1mAuWbfe+Ec+HRdMgXKleurK+//lqdO3eWxWLR6NGjc/UXy6wMGTJEMTExqlSpksLCwjRx4kSdOXMmW5M57dy5U76+vtZ1i8WiOnXqqGvXrhowYIA++ugj+fr66vnnn1epUqXUtWtXSdKwYcMUHh6uKlWq6MyZM1q1apWqVasmSRozZozq16+vGjVqKDU1Vd9++611GwDkVHJysuLj423KBg4cqAkTJmjIkCEaPHiwEhISNHbsWI0YMUIuLi7auHGjVq5cqfvuu0+BgYHauHGj/vjjD1WrVk2HDh3StGnT1KVLF5UsWVIJCQnat2+f+vTp45gOAnAKPj4+evjhhxUVFaWUlBT17dvXuq1y5cr68ssvtX79ehUpUkTvvfeekpKSbBLVm2nbtq2qVKmiiIgIvf3220pJSdGLL75oU6dy5co6evSo5s+fr4YNG+q7776z+YFS+meG/EOHDik+Pl6lS5eWr6+vPDw8bOr07t1bY8eOVUREhMaNG6c//vhDQ4YM0WOPPaagoKDbOzj/X1paWobztYeHh9q2batatWqpd+/emjBhgq5evapBgwapZcuWatCggf7++289++yzevDBB1W+fHkdP35ccXFx6tGjh6Sbf++E8yGZR77w3nvv6fHHH1fTpk1VvHhxjRo1SikpKXkex6hRo5SYmKg+ffrI1dVVAwcOVPv27W3uc8pKixYtbNZdXV119epVzZo1S0OHDlWnTp10+fJltWjRQt9//731kqu0tDRFRkbq+PHj8vPzU4cOHayzqbq7uysqKkqHDx+Wl5eXmjdvrvnz59u/4wD+FVavXq169erZlPXv31/ff/+9nn32WdWpU0dFixZV//799dJLL0mS/Pz8tHbtWk2YMEEpKSkqW7as3n33XYWHhyspKUm//fab5syZo9OnTyskJESRkZF68sknHdE9AE6kf//+mjFjhu6//36b+9tfeuklHTx4UO3bt1fhwoU1cOBAdevWTcnJydlq18XFRYsWLVL//v3VqFEjlStXTh988IE6dOhgrdOlSxcNHz5cgwcPVmpqqjp27KjRo0dr3Lhx1jo9evTQ119/rdatW+vs2bOaNWuWzY8O0j9zMS1btkxDhw5Vw4YNVbhwYfXo0UPvvffeHR0b6Z/5pG48X1esWFH79+/XN998oyFDhqhFixZycXFRhw4drJfKu7q66vTp0+rTp4+SkpJUvHhxde/eXdHR0ZJu/r0TzsdiHH3DMJCPpaenq1q1aurZs6deeeUVR4cDAAAAAJIYmQdsHDlyRD/++KNatmyp1NRUffjhhzp06JD+85//ODo0AAAAALBiAjzgOi4uLpo9e7YaNmyoZs2aaefOnVqxYgX3EgEAAADIV7jMHgAAAAAAJ8PIPAAAAAAAToZkHgAAAAAAJ0MyDwAAAACAkyGZBwAAAADAyZDMAwAAAADgZEjmAQAAAABwMiTzAAAAAAA4GZJ5AAAAAACcDMk8AAAAAABO5v8B/c7uYKCKAEwAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1,3, figsize=(12,4))\n", + "\n", + "x_min, x_max = 0.0003, 0.0008 # account for outliers in the uniform loss. no major difference on this graph when zooming in around 3.5e-4\n", + "bins = np.linspace(x_min, x_max, 20)\n", + "ax[0].hist(all_spec_train_loss, bins=bins, alpha=0.5)\n", + "ax[0].hist(all_unif_train_loss, bins=bins, alpha=0.5)\n", + "ax[0].set_xlabel(\"Training Loss\")\n", + "ax[0].set_ylabel(\"Count\")\n", + "\n", + "ax[1].hist(all_spec_loss, bins=20, alpha=0.5)\n", + "ax[1].hist(all_unif_loss, bins=20, alpha=0.5)\n", + "ax[1].set_xlabel(\"Loss\")\n", + "\n", + "ax[2].hist(all_spec_validate_loss, bins=20, label=\"Spectral Init\", alpha=0.5)\n", + "ax[2].hist(all_unif_validate_loss, bins=20, label=\"Uniform Init\", alpha=0.5)\n", + "ax[2].set_xlabel(\"Validation Loss\")\n", + "ax[2].legend()\n", + "\n", + "fig.suptitle(\"Loss for Sparse Sample, 10k Ratings\")\n", + "fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 3, figsize=(12, 4))\n", + "\n", + "# Layered histogram for training loss\n", + "ax[0].hist(all_spec_train_loss_dense, bins=20, alpha=0.5)\n", + "ax[0].hist(all_unif_train_loss_dense, bins=20, alpha=0.5)\n", + "ax[0].set_xlabel(\"Training Loss\")\n", + "ax[0].set_ylabel(\"Count\")\n", + "\n", + "# Layered histogram for loss\n", + "ax[1].hist(all_spec_loss_dense, bins=20, alpha=0.5)\n", + "ax[1].hist(all_unif_loss_dense, bins=20, alpha=0.5)\n", + "ax[1].set_xlabel(\"Loss\")\n", + "\n", + "# Layered histogram for validation loss\n", + "ax[2].hist(all_spec_validate_loss_dense, bins=20, alpha=0.5, label=\"Spectral Init\")\n", + "ax[2].hist(all_unif_validate_loss_dense, bins=20, alpha=0.5, label=\"Uniform Init\")\n", + "ax[2].set_xlabel(\"Validation Loss\")\n", + "ax[2].legend()\n", + "\n", + "fig.suptitle(\"Loss for Dense Sample, 10k Users and 10k Notes\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 3, figsize=(12, 2))\n", + "\n", + "for data in [all_spec_train_loss_30k, all_unif_train_loss_30k]:\n", + " ax[0].plot(data, np.zeros_like(data) + 0.01, '|', markersize=10)\n", + "ax[0].set_xlabel(\"Training Loss\")\n", + "ax[0].yaxis.set_visible(False)\n", + "\n", + "for data in [all_spec_loss_30k, all_unif_loss_30k]:\n", + " ax[1].plot(data, np.zeros_like(data) + 0.01, '|', markersize=10)\n", + "ax[1].set_xlabel(\"Loss\")\n", + "ax[1].yaxis.set_visible(False)\n", + "\n", + "for data, label in zip([all_spec_validate_loss_30k, all_unif_validate_loss_30k], [\"Spectral Init\", \"Uniform Init\"]):\n", + " ax[2].plot(data, np.zeros_like(data) + 0.01, '|', markersize=10, label=label)\n", + "ax[2].set_xlabel(\"Validation Loss\")\n", + "ax[2].legend()\n", + "ax[2].yaxis.set_visible(False)\n", + "\n", + "fig.suptitle(\"Rugplot: Loss for Sparse Sample, 30k Ratings\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1, 3, figsize=(12, 2))\n", + "\n", + "for data in [all_spec_train_loss_30k_dense, all_unif_train_loss_30k_dense]:\n", + " ax[0].plot(data, np.zeros_like(data) + 0.01, '|', markersize=10)\n", + "ax[0].set_xlabel(\"Training Loss\")\n", + "ax[0].yaxis.set_visible(False)\n", + "\n", + "for data in [all_spec_loss_30k_dense, all_unif_loss_30k_dense]:\n", + " ax[1].plot(data, np.zeros_like(data) + 0.01, '|', markersize=10)\n", + "ax[1].set_xlabel(\"Loss\")\n", + "ax[1].yaxis.set_visible(False)\n", + "\n", + "for data, label in zip([all_spec_validate_loss_30k_dense, all_unif_validate_loss_30k_dense], [\"Spectral Init\", \"Uniform Init\"]):\n", + " ax[2].plot(data, np.zeros_like(data) + 0.01, '|', markersize=10, label=label)\n", + "ax[2].set_xlabel(\"Validation Loss\")\n", + "ax[2].legend()\n", + "ax[2].yaxis.set_visible(False)\n", + "\n", + "fig.suptitle(\"Rugplot: Loss for Dense Sample, 30k Users and 30k Notes\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\iijof\\AppData\\Local\\Temp\\ipykernel_5220\\4269532440.py:21: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " fig.show()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(2, 2, figsize=(10,6))\n", + "\n", + "ax[0][0].hist(all_spec_fitNoteParams[0][\"internalNoteIntercept\"], bins=100, alpha=0.5)\n", + "ax[0][0].hist( all_unif_fitNoteParams[0][\"internalNoteIntercept\"], bins=100, alpha=0.5)\n", + "ax[0][0].set_xlabel(\"Fitted Note Intercepts\")\n", + "\n", + "ax[0][1].hist(all_spec_fitNoteParams[0][\"internalNoteFactor1\"], bins=100, alpha=0.5, label=\"Spectral Init\")\n", + "ax[0][1].hist(all_unif_fitNoteParams[0][\"internalNoteFactor1\"], bins=100, alpha=0.5, label=[\"Uniform Init\"])\n", + "ax[0][1].set_xlabel(\"Fitted Note Factor1s\")\n", + "ax[0][1].legend()\n", + "\n", + "ax[1][0].hist(all_spec_fitRaterParams[0][\"internalRaterIntercept\"], bins=100, alpha=0.5)\n", + "ax[1][0].hist(all_unif_fitRaterParams[0][\"internalRaterIntercept\"], bins=100, alpha=0.5)\n", + "ax[1][0].set_xlabel(\"Fitted Rater Intercepts\")\n", + "\n", + "ax[1][1].hist(all_spec_fitRaterParams[0][\"internalRaterFactor1\"], bins=100, alpha=0.5)\n", + "ax[1][1].hist(all_unif_fitRaterParams[0][\"internalRaterFactor1\"], bins=100, alpha=0.5)\n", + "ax[1][1].set_xlabel(\"Fitted Rater Factor1s\")\n", + "\n", + "fig.suptitle(\"Fitted Parameters for One Spase Sample, 10k Ratings\")\n", + "fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\iijof\\AppData\\Local\\Temp\\ipykernel_5220\\1918245580.py:10: UserWarning: No artists with labels found to put in legend. Note that artists whose label start with an underscore are ignored when legend() is called with no argument.\n", + " ax[0][1].legend()\n", + "C:\\Users\\iijof\\AppData\\Local\\Temp\\ipykernel_5220\\1918245580.py:21: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " fig.show()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(2, 2, figsize=(10,6))\n", + "\n", + "ax[0][0].hist(all_spec_fitNoteParams_dense[0][\"internalNoteIntercept\"], bins=100, alpha=0.5)\n", + "ax[0][0].hist(all_unif_fitNoteParams_dense[0][\"internalNoteIntercept\"], bins=100, alpha=0.5)\n", + "ax[0][0].set_xlabel(\"Fitted Note Intercepts\")\n", + "\n", + "ax[0][1].hist(all_spec_fitNoteParams_dense[0][\"internalNoteFactor1\"], bins=100, alpha=0.5)\n", + "ax[0][1].hist(all_unif_fitNoteParams_dense[0][\"internalNoteFactor1\"], bins=100, alpha=0.5)\n", + "ax[0][1].set_xlabel(\"Fitted Note Factor1s\")\n", + "ax[0][1].legend()\n", + "\n", + "ax[1][0].hist(all_spec_fitRaterParams_dense[0][\"internalRaterIntercept\"], bins=100, alpha=0.5)\n", + "ax[1][0].hist(all_unif_fitRaterParams_dense[0][\"internalRaterIntercept\"], bins=100, alpha=0.5)\n", + "ax[1][0].set_xlabel(\"Fitted Rater Intercepts\")\n", + "\n", + "ax[1][1].hist(all_spec_fitRaterParams_dense[0][\"internalRaterFactor1\"], bins=100, alpha=0.5)\n", + "ax[1][1].hist(all_unif_fitRaterParams_dense[0][\"internalRaterFactor1\"], bins=100, alpha=0.5)\n", + "ax[1][1].set_xlabel(\"Fitted Rater Factor1s\")\n", + "\n", + "fig.suptitle(\"Fitted Parameters for One Dense Sample, 10k Users and 10k Notes\")\n", + "fig.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The spectral initialization generally gives a higher global intercept than the uniform initialization. When the line 245 bug was present and the global intercept got stuck around the average rating value, I observed that generalization was actually even better than when the global intercept was gradually learned. From breifly experimenting with different permanant global intercept choices, I believe that some, but not all of the improved generalization of the spectral initialization is due to this. It makes sense that a high global intercept helps to generalize because it's able to use every rating to fit. \n", + "\n", + "While I understand that the motivation of regularizing the intercepts more than factors to push weight off of the intercepts, I'm not sure why this would apply to the global intercept. I don't think I agree with the design choice to heavily regularize it, especially in light of finding that it's useful for generalization, but I'd love to know if there's a reason I haven't thought of. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Iterative Spectral Initialization\n", + "\n", + "I also had the idea to run several iterations of optimization using the SVD. In the first, nan values in the data are filled with user and note means, but in subsequent rounds of optimization, the spectral initialization's SVD uses the data matrix where the nans are filled with the sum of the note and user's intercept, as learned in the previous round. Ultimately, I found that this had little impact and was sometimes even harmful. For the sparse samples, the parameters had almost no movement past the first round. For the dense samples, some did move around, but not in an obviously convergent way (at least in one dimension, I didn't check past that) and it did not lead to improvement in loss. This is still interesting though because it suggests that the low-loss optima found using spectral initialization aren't extremely unique and special. \n", + "\n", + "I left the code in since maybe it could be made to work with some further tweaks. One such idea that I haven't yet tested would be to add noise to the data within each round, and then take some kind of average of the parameters that each round finds. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Update: Low-Memory SVD!" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Previously, SVD failed when attempting to run the algorithm with over a few million ratings. This is because it requires building the full notes x raters matrix, which either took up too much memory and crashed my notebook, or caused errors on the call to pandas' `pivot` on line 188. Luckily, the notes x raters matrix is extremely sparse (most raters have not rated most notes), and the scipy.sparse library is built for handling this, by storing the matrix in a format more similar to the three-column format in `modelData`. \n", + "\n", + "The updated code has a `saveMemory` parameter when calling `run_mf`, which will use scipy instead of pandas and numpy to do the linear algebra. It is off by default. When it's on, my laptop is able to do the SVD for any data size I gave it. It's still a bit slow for the several-million-rating samples, but I don't think it's that much slower than the gradient descent phase and expect it would be much faster, perhaps satisfactorily fast, on X's hardware. \n", + "\n", + "The disadvantage of using the sparse representation is that you have less control over filling in the missing values for the SVD. You must fill them all with the same value (e.g. the overall mean rating), and then subtract that value before SVD to create sparseness. On the other hand, I actually saw some loss *improvement* when using the sparse representation, which I can only imagine is due to this change in filling missing values. So I'm currently thinking about why that might be the case, as well as about other potentially beneficial normalization strategies. Overall, I'm a bit philosophically concerned that the missing value interpolation may make the algorithm give too much sway to raters or notes without many ratings. But, the filled values are still not included in the loss, which descreases, so again I don't know exactly how to think about it at this moment. \n", + "\n", + "I haven't had time to benchmark the time, space, or especially accuracy to be confident enough to put graphs here, but hope to have a chance soon! I also haven't taken the time to apply this to iterative spectral initialization, since that didn't work in the first place. " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "communitynotes_env", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}