From 7d193d87b125f2d35acb8c4dd5becd575c2a65e2 Mon Sep 17 00:00:00 2001 From: IanJoffe Date: Wed, 28 Aug 2024 19:13:49 -0500 Subject: [PATCH 1/7] SVD for working initialization on full data --- .../matrix_factorization.py | 42 +++++++++++++++---- 1 file changed, 35 insertions(+), 7 deletions(-) diff --git a/sourcecode/scoring/matrix_factorization/matrix_factorization.py b/sourcecode/scoring/matrix_factorization/matrix_factorization.py index e512bdde2..3d9490e81 100644 --- a/sourcecode/scoring/matrix_factorization/matrix_factorization.py +++ b/sourcecode/scoring/matrix_factorization/matrix_factorization.py @@ -9,6 +9,7 @@ import numpy as np import pandas as pd import torch +from scipy.sparse.linalg import svds logger = logging.getLogger("birdwatch.matrix_factorization") @@ -180,12 +181,12 @@ def _initialize_parameters( if noteInit is not None: if self._log: logger.info("initializing notes") - noteInit = self.noteIdMap.merge( - noteInit, - on=c.noteIdKey, - how="left", - unsafeAllowed={c.noteIdKey, "noteIndex_y"}, - ) + # noteInit = self.noteIdMap.merge( + # noteInit, + # on=c.noteIdKey, + # how="left", + # unsafeAllowed={c.noteIdKey, "noteIndex_y"}, + # ) noteInit[c.internalNoteInterceptKey].fillna(0.0, inplace=True) self.mf_model.note_intercepts.weight.data = torch.tensor( @@ -434,7 +435,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 +497,7 @@ def run_mf( noteInit: pd.DataFrame = None, userInit: pd.DataFrame = None, globalInterceptInit: Optional[float] = None, + useSpectralInit: Optional[bool] = False, specificNoteId: Optional[int] = None, validatePercent: Optional[float] = None, freezeRaterParameters: bool = False, @@ -524,6 +527,31 @@ def run_mf( self._initialize_note_and_rater_id_maps(ratings) + if useSpectralInit: + + # self._create_train_validate_sets(validatePercent) + model_data = ModelData(self.ratingFeaturesAndLabels, self.raterIdMap, self.noteIdMap) # fix: training on test data + data_matrix = model_data.rating_labels.pivot(index='raterIndex', columns='noteIndex', values='helpfulNum').values + mean_matrix = (np.nanmean(data_matrix, axis=1)[:,np.newaxis] + np.nanmean(data_matrix, axis=0)) / 2 - np.nanmean(data_matrix) # fix: do regression for optimal weights + filled_matrix = np.where(np.isnan(data_matrix), mean_matrix, data_matrix) + + U, S, Vt = svds(filled_matrix, k=1) + note_factor_init_vals = np.sqrt(S[0]) * Vt[0] + user_factor_init_vals = np.sqrt(S[0]) * U.T[0] + + noteInit = pd.DataFrame({ + c.noteIdKey: self.noteIdMap["noteId"], + c.note_factor_key(1): note_factor_init_vals, + c.internalNoteInterceptKey: np.zeros(len(note_factor_init_vals)) + }) + userInit = pd.DataFrame({ + c.raterParticipantIdKey: self.raterIdMap["raterParticipantId"], + c.rater_factor_key(1): user_factor_init_vals, + c.internalRaterInterceptKey: np.zeros(len(user_factor_init_vals)) + }) + globalInterceptInit = np.nanmean(data_matrix) + + self._create_mf_model(noteInit, userInit, globalInterceptInit) assert self.mf_model is not None From a2186aef35c3d3c1928ccd18bdc770bff493d43a Mon Sep 17 00:00:00 2001 From: IanJoffe Date: Thu, 29 Aug 2024 17:21:41 -0500 Subject: [PATCH 2/7] spectral init with valid data --- .../matrix_factorization.py | 69 ++++++++++--------- 1 file changed, 38 insertions(+), 31 deletions(-) diff --git a/sourcecode/scoring/matrix_factorization/matrix_factorization.py b/sourcecode/scoring/matrix_factorization/matrix_factorization.py index 3d9490e81..8f4e9e396 100644 --- a/sourcecode/scoring/matrix_factorization/matrix_factorization.py +++ b/sourcecode/scoring/matrix_factorization/matrix_factorization.py @@ -181,12 +181,12 @@ def _initialize_parameters( if noteInit is not None: if self._log: logger.info("initializing notes") - # noteInit = self.noteIdMap.merge( - # noteInit, - # on=c.noteIdKey, - # how="left", - # unsafeAllowed={c.noteIdKey, "noteIndex_y"}, - # ) + noteInit = self.noteIdMap.merge( + noteInit, + on=c.noteIdKey, + 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) self.mf_model.note_intercepts.weight.data = torch.tensor( @@ -527,31 +527,6 @@ def run_mf( self._initialize_note_and_rater_id_maps(ratings) - if useSpectralInit: - - # self._create_train_validate_sets(validatePercent) - model_data = ModelData(self.ratingFeaturesAndLabels, self.raterIdMap, self.noteIdMap) # fix: training on test data - data_matrix = model_data.rating_labels.pivot(index='raterIndex', columns='noteIndex', values='helpfulNum').values - mean_matrix = (np.nanmean(data_matrix, axis=1)[:,np.newaxis] + np.nanmean(data_matrix, axis=0)) / 2 - np.nanmean(data_matrix) # fix: do regression for optimal weights - filled_matrix = np.where(np.isnan(data_matrix), mean_matrix, data_matrix) - - U, S, Vt = svds(filled_matrix, k=1) - note_factor_init_vals = np.sqrt(S[0]) * Vt[0] - user_factor_init_vals = np.sqrt(S[0]) * U.T[0] - - noteInit = pd.DataFrame({ - c.noteIdKey: self.noteIdMap["noteId"], - c.note_factor_key(1): note_factor_init_vals, - c.internalNoteInterceptKey: np.zeros(len(note_factor_init_vals)) - }) - userInit = pd.DataFrame({ - c.raterParticipantIdKey: self.raterIdMap["raterParticipantId"], - c.rater_factor_key(1): user_factor_init_vals, - c.internalRaterInterceptKey: np.zeros(len(user_factor_init_vals)) - }) - globalInterceptInit = np.nanmean(data_matrix) - - self._create_mf_model(noteInit, userInit, globalInterceptInit) assert self.mf_model is not None @@ -578,6 +553,38 @@ 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_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=0.0)[:,np.newaxis] + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=0.0) - np.nanmean(data_matrix) # fix: do regression for optimal weights + filled_matrix = np.where(np.isnan(data_matrix), mean_matrix, data_matrix) + + U, S, Vt = svds(filled_matrix, k=1) + 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, # self.noteIdMap["noteId"], + 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, # self.raterIdMap["raterParticipantId"], + c.rater_factor_key(1): user_factor_init_vals, + c.internalRaterInterceptKey: np.zeros(len(user_factor_init_vals)) + }) + globalInterceptInit = np.nanmean(data_matrix) + + self._initialize_parameters(noteInit, userInit, globalInterceptInit) + train_loss, loss, validate_loss = self._fit_model(validatePercent) if self._normalizedLossHyperparameters is not None: _, raterParams = self._get_parameters_from_trained_model() From 11a3f983be1fb1667760aa0b4b7b40b174e65e5b Mon Sep 17 00:00:00 2001 From: IanJoffe Date: Fri, 30 Aug 2024 16:29:28 -0500 Subject: [PATCH 3/7] bug fixes and initial tests on spectral init --- .../matrix_factorization.py | 16 +- sourcecode/test_mf.ipynb | 463 ++++++++++++++++++ 2 files changed, 471 insertions(+), 8 deletions(-) create mode 100644 sourcecode/test_mf.ipynb diff --git a/sourcecode/scoring/matrix_factorization/matrix_factorization.py b/sourcecode/scoring/matrix_factorization/matrix_factorization.py index 8f4e9e396..45792deab 100644 --- a/sourcecode/scoring/matrix_factorization/matrix_factorization.py +++ b/sourcecode/scoring/matrix_factorization/matrix_factorization.py @@ -188,13 +188,13 @@ def _initialize_parameters( # 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 anywhere 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) @@ -206,13 +206,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) @@ -563,8 +563,8 @@ def run_mf( 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=0.0)[:,np.newaxis] + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=0.0) - np.nanmean(data_matrix) # fix: do regression for optimal weights + data_matrix = data_df.values # fix: get better weights than 1/2, 1/2 on next line + mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=0.0)[:,np.newaxis] + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=0.0) - np.nanmean(data_matrix) # warning can be ignored, I deal with it on the next line filled_matrix = np.where(np.isnan(data_matrix), mean_matrix, data_matrix) U, S, Vt = svds(filled_matrix, k=1) @@ -572,12 +572,12 @@ def run_mf( user_factor_init_vals = np.sqrt(S[0]) * Vt[0] noteInit = pd.DataFrame({ - c.noteIdKey: data_df.index, # self.noteIdMap["noteId"], + 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, # self.raterIdMap["raterParticipantId"], + c.raterParticipantIdKey: data_df.columns, c.rater_factor_key(1): user_factor_init_vals, c.internalRaterInterceptKey: np.zeros(len(user_factor_init_vals)) }) diff --git a/sourcecode/test_mf.ipynb b/sourcecode/test_mf.ipynb new file mode 100644 index 000000000..6d4cdc767 --- /dev/null +++ b/sourcecode/test_mf.ipynb @@ -0,0 +1,463 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Testing the Spectral Initialization" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "I noticed that previously, 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 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": 50, + "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.matrix_factorization.normalized_loss import NormalizedLossHyperparameters\n", + "from scoring.process_data import preprocess_data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "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": 2, + "metadata": {}, + "outputs": [], + "source": [ + "preprocessed_ratings_df_sample = pd.read_csv(\"ratings-00009-preprocessed.tsv\", sep='\\t')" + ] + }, + { + "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, 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, 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", + " 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_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, 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": "code", + "execution_count": 94, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\iijof\\AppData\\Local\\Temp\\ipykernel_41056\\3455664907.py:20: 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": [ + "# I accidently sorted all_unif_train_loss\n", + "\n", + "fig, ax = plt.subplots(1,3, figsize=(12,4))\n", + "\n", + "x_min, x_max = 0.0003, 0.0005 # cut out one outlier to the right with the of all_train_loss_unif\n", + "bins = np.linspace(x_min, x_max, 100)\n", + "ax[0].set_xlim(x_min, x_max)\n", + "ax[0].hist([all_spec_train_loss, all_unif_train_loss], bins=bins)\n", + "ax[0].set_xlabel(\"Training Loss\")\n", + "ax[0].set_ylabel(\"Count\")\n", + "\n", + "ax[1].hist([all_spec_loss, all_unif_loss], bins=100)\n", + "ax[1].set_xlabel(\"Loss\")\n", + "\n", + "ax[2].hist([all_spec_validate_loss, all_unif_validate_loss], bins=100, label=[\"Spectral Init\", \"Uniform Init\"])\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": 98, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\iijof\\AppData\\Local\\Temp\\ipykernel_41056\\4160637875.py:15: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + " fig.show()\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9wAAAGbCAYAAAA2kpjgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAABpTElEQVR4nO3de3zP9f//8ft757GTw2ZbZnNmc8wp52PmTCmRckj0qVHogE+EKHQkSag2KpFy+lTImYpyWhEJTYhNyTaUje35+8Nv76+3Ddvsvfc2t+vl8rrY6/l6vl+vx/P1er2fXo/362QxxhgBAAAAAIA85eToAAAAAAAAKIpIuAEAAAAAsAMSbgAAAAAA7ICEGwAAAAAAOyDhBgAAAADADki4AQAAAACwAxJuAAAAAADsgIQbAAAAAAA7IOEGAAAAAMAOSLgB4BasXr1aderUkYeHhywWixITEx0dEhzo6NGjslgsiomJcXQoOTZgwAB5eXk5OozbTlhYmAYMGOCQZVssFg0dOtQhywaA2wUJN4ACJyYmRhaLRTt37nR0KDd05swZ9erVS56enpo1a5Y+/PBDFS9e3G7Ly1gvGYOHh4eCg4MVGRmpt956S+fOnbPbsvPbN998o44dO+qOO+6Qh4eHypUrp65du2rhwoWODq1AOHjwoEaMGKEmTZpYf+w5evTodeuvXLlSd955p3Vdjh8/XpcvX86zeG6WrHt5eTksqSwqFi9erIceekiVK1eWxWJRq1atrls3JSVFo0aNUnBwsDw9PdWoUSOtXbs2T+MJCwuTxWLRsGHDMk3btGmTLBaLPvvssxzPd//+/ZowYcIN92cAKExIuAEgl3bs2KFz585p0qRJGjRokB566CG5urrafbkvvviiPvzwQ82ePdt6sDt8+HDVrFlTP/30k92Xb29LlixRixYtlJCQoKeeekozZ87UQw89pLNnz2revHmODq9A2LZtm/VHlurVq9+w7qpVq9SjRw/5+flp5syZ6tGjhyZPnpxlooSCa/bs2VqxYoVCQkJUokSJG9YdMGCA3njjDfXt21czZsyQs7OzOnXqpG+++SbP45o3b55OnjyZZ/Pbv3+/Jk6cSMINoMhwcXQAAFBYnT59WpLk5+eXZ/O8cOHCTc+Sd+zYUfXr17eOjxkzRhs2bFCXLl3UrVs3HThwQJ6ennkWU36bMGGCwsPDtX37drm5udlMy1jnt7tu3bopMTFR3t7eeu211xQbG3vdus8884xq1aqlr7/+Wi4uV/7b9/Hx0csvv6ynnnpK1apVy6eo8092vkeFzYcffqg77rhDTk5OqlGjxnXr/fDDD1q0aJFeffVVPfPMM5Kkfv36qUaNGnruuef03Xff5VlMEREROnjwoKZOnaq33norz+YLAEUJZ7gBFFp79uxRx44d5ePjIy8vL7Vt21bbt2+3qXPp0iVNnDhRlStXloeHh0qVKqVmzZrZXF4ZHx+vgQMHqmzZsnJ3d1dQUJC6d+9+wzMsrVq1Uv/+/SVJDRo0kMVisblkdsmSJapXr548PT1VunRpPfTQQ/rjjz9s5pFxGe6RI0fUqVMneXt7q2/fvrlaF23atNG4ceP0+++/66OPPrKZ9ssvv+i+++5TyZIl5eHhofr162vlypU2dTIuV//22281cuRI+fv7q3jx4rrnnnv0559/2tTduXOnIiMjVbp0aXl6eqp8+fJ65JFHbOqkp6dr+vTpioiIkIeHh8qUKaPHHntMZ8+evWlbjhw5ogYNGmRKtiUpICDAZvy1115TkyZNVKpUKXl6eqpevXpZXsaaca/qkiVLFB4eLk9PTzVu3Fh79+6VJM2ZM0eVKlWSh4eHWrVqlWnbt2rVSjVq1NCuXbvUpEkTa7vffffdm7ZHyt42yImSJUvK29v7pvX279+v/fv3a8iQIdZkW5KeeOIJGWNueslvbGys/P391apVK50/fz7X8V4rO99LKWf77ubNm/XEE08oICBAZcuWlSSdO3dOw4cPV1hYmNzd3RUQEKC7775bu3fvvmF8v//+u5544glVrVpVnp6eKlWqlO6///5M+0VOvjfGGE2ePFlly5ZVsWLF1Lp1a/3888/ZXmchISFycrr5Ydtnn30mZ2dnDRkyxFrm4eGhQYMGadu2bTp+/PgNPz958mQ5OTlp5syZN11WWFiY+vXrl+2z3Dfrs2NiYnT//fdLklq3bm29fWbTpk3WOqtWrVLz5s1VvHhxeXt7q3PnzpnWY276dACwF85wAyiUfv75ZzVv3lw+Pj567rnn5Orqqjlz5qhVq1bavHmzGjVqJOnK2dIpU6bo0UcfVcOGDZWcnKydO3dq9+7duvvuuyVJPXv21M8//6xhw4YpLCxMp0+f1tq1a3Xs2DGFhYVlufznn39eVatW1dy5c/Xiiy+qfPnyqlixoqQrB40DBw5UgwYNNGXKFCUkJGjGjBn69ttvtWfPHpsz4pcvX1ZkZKSaNWum1157TcWKFcv1Onn44Yf13//+V19//bUGDx5sXU9NmzbVHXfcodGjR6t48eL69NNP1aNHD33++ee65557bOYxbNgwlShRQuPHj9fRo0c1ffp0DR06VIsXL5Z05Qxz+/bt5e/vr9GjR8vPz09Hjx7V0qVLbebz2GOPWdfDk08+qbi4OL399tvas2ePvv322xteeh8aGqr169frxIkT1sTpembMmKFu3bqpb9++Sk1N1aJFi3T//ffriy++UOfOnW3qbt26VStXrlRUVJQkacqUKerSpYuee+45vfPOO3riiSd09uxZvfLKK3rkkUe0YcMGm8+fPXtWnTp1Uq9evdSnTx99+umnevzxx+Xm5pbpB4er5XQb5KU9e/ZIks0VEZIUHByssmXLWqdnZceOHYqMjFT9+vW1YsWKPL1qIjvfy5yutyeeeEL+/v564YUXdOHCBUnSf/7zH3322WcaOnSowsPDdebMGX3zzTc6cOCA7rzzzhu2/bvvvlPv3r1VtmxZHT16VLNnz1arVq20f//+TN/Tm31vJOmFF17Q5MmT1alTJ3Xq1Em7d+9W+/btlZqamlerVdKVbV6lShX5+PjYlDds2FDSlR9RQkJCsvzs2LFj9fLLL2vOnDnWPuRmnn/+eS1YsOCmZ7mz02e3aNFCTz75pN566y3997//td4ukfHvhx9+qP79+ysyMlLTpk3TP//8o9mzZ6tZs2bas2ePtb/OTZ8OAHZjAKCAiY6ONpLMjh07rlunR48exs3NzRw5csRadvLkSePt7W1atGhhLatdu7bp3Lnzdedz9uxZI8m8+uqreRJnamqqCQgIMDVq1DD//vuvtfyLL74wkswLL7xgLevfv7+RZEaPHp3r5V3L19fX1K1b1zretm1bU7NmTXPx4kVrWXp6umnSpImpXLlypnm3a9fOpKenW8tHjBhhnJ2dTWJiojHGmGXLlt00hq1btxpJ5uOPP7YpX716dZbl13r//feNJOPm5mZat25txo0bZ7Zu3WrS0tIy1f3nn39sxlNTU02NGjVMmzZtbMolGXd3dxMXF2ctmzNnjpFkAgMDTXJysrV8zJgxRpJN3ZYtWxpJ5vXXX7eWpaSkmDp16piAgACTmppqjDEmLi7OSDLR0dHWetndBrn16quvZor32mnHjh3LNK1Bgwbmrrvuso7379/fFC9e3BhjzDfffGN8fHxM586dbeK+nqs/m5XixYub/v37W8dv9r00Juf7brNmzczly5dt5uHr62uioqJuGv+1rt2vjDFm27ZtRpJZsGBBpmXf7Htz+vRp4+bmZjp37mxT77///a+RZLNusiMiIsK0bNnyutOu3f+NMebnn382ksy7775rLZNkXT9PP/20cXJyMjExMdmKITQ01LoNBw4caDw8PMzJkyeNMcZs3LjRSDJLliyx1s9un71kyRIjyWzcuNFmeefOnTN+fn5m8ODBNuXx8fHG19fXWn4rfToA2AOXlAModNLS0vT111+rR48eqlChgrU8KChIDz74oL755hslJydLunJ/9c8//6xDhw5lOS9PT0+5ublp06ZN2brc+WZ27typ06dP64knnpCHh4e1vHPnzqpWrZq+/PLLTJ95/PHHb3m5Gby8vKxPK//777+1YcMG9erVS+fOndNff/2lv/76S2fOnFFkZKQOHTqU6TL3IUOGyGKxWMebN2+utLQ0/f7775L+7371L774QpcuXcoyhiVLlsjX11d33323dZl//fWX6tWrJy8vL23cuPGGbXjkkUe0evVqtWrVSt98840mTZqk5s2bq3LlypnuP736rOvZs2eVlJSk5s2bZ3nJcNu2bW3ObmVcBdGzZ0+by7Mzyn/77Tebz7u4uOixxx6zjru5uemxxx7T6dOntWvXrizbkpttkJf+/fdfSZK7u3umaR4eHtbpV9u4caMiIyPVtm1bLV26NMvP3qqbfS9zs94GDx4sZ2fnTMv5/vvvc/xQr6v3q0uXLunMmTOqVKmS/Pz8sty3bva9WbdunVJTUzVs2DCbesOHD89RXNnx77//Xnd7Z0y/mjFGQ4cO1YwZM/TRRx9Zb5XJibFjx+ry5cuaOnVqltNz0mdfz9q1a5WYmKg+ffrY9CvOzs5q1KiRtV/J6z4dAG4VCTeAQufPP//UP//8o6pVq2aaVr16daWnp1vvU3zxxReVmJioKlWqqGbNmnr22WdtnuTt7u6uadOmadWqVSpTpoxatGihV155RfHx8bmKLeMAO6vYqlWrZp2ewcXF5aaXTefE+fPnrcnj4cOHZYzRuHHj5O/vbzOMHz9eUuaHkJUrV85mPONpyBkHri1btlTPnj01ceJElS5dWt27d1d0dLRSUlKsnzl06JCSkpIUEBCQabnnz5/P1oPPIiMjtWbNGiUmJmrLli2KiorS77//ri5duth8/osvvtBdd90lDw8PlSxZUv7+/po9e7aSkpIyzfPatvn6+kpSpstrM8qvPVgPDg7O9CCuKlWqSNJ17w3NzTbISxmJ49XbJ8PFixczXSZ+8eJFde7cWXXr1tWnn36a5X30uXV1onmz72Vu1lv58uUzLfOVV17Rvn37FBISooYNG2rChAmZfkjJyr///qsXXnhBISEhcnd3V+nSpeXv76/ExMRs7VvXfm8yvveVK1e2qefv73/TJ47nlKen53W3d8b0qy1YsECzZs3SzJkz1adPn1wts0KFCnr44Yc1d+5cnTp1KtP0nPTZ15Px40ybNm0y7RNff/21dX/I6z4dAG4V93ADKNJatGihI0eOaMWKFfr666/13nvv6c0339S7776rRx99VNKVs0xdu3bV8uXLtWbNGo0bN05TpkzRhg0bVLduXbvG5+7unq0HIWXHiRMnlJSUpEqVKkm68uAy6cpTqiMjI7P8TEbdDNeeIcxgjJEk67t1t2/frv/9739as2aNHnnkEb3++uvavn27vLy8lJ6eroCAAH388cdZzsvf3z/bbSpWrJiaN2+u5s2bq3Tp0po4caJWrVql/v37a+vWrerWrZtatGihd955R0FBQXJ1dVV0dHSW7+u+Xttu1uZbkZttkJeCgoIkSadOncr0w8KpU6es9/VmcHd3V6dOnbRixQqtXr1aXbp0ydZyPDw8lJKSImOMTWItXVmPFy9etLni42bfy9yst6zuMe/Vq5eaN2+uZcuW6euvv9arr76qadOmaenSperYseN12zNs2DBFR0dr+PDhaty4sXx9fWWxWNS7d29rbFez5z6UU0FBQVleNZGRCAcHB9uUN23aVLGxsXr77bfVq1cvlSxZMlfLff755/Xhhx9q2rRp6tGjR67mcSMZ6/3DDz9UYGBgpulXPxTQkX06AFyLhBtAoePv769ixYrp4MGDmab98ssvcnJyskkuSpYsqYEDB2rgwIE6f/68WrRooQkTJlgTbkmqWLGinn76aT399NM6dOiQ6tSpo9dffz3TE79vJjQ0VJJ08OBBtWnTxmbawYMHrdPt4cMPP5Qka4KScemmq6ur2rVrl6fLuuuuu3TXXXfppZde0sKFC9W3b18tWrRIjz76qCpWrKh169apadOmefqgrYwHf2UkDp9//rk8PDy0Zs0am0too6Oj82yZVzt58mSm1039+uuvknTdBzHZcxtkR506dSRdudXh6uT65MmTOnHihM2TrKUrP6h8/PHH6t69u+6//36tWrVKrVq1uulyQkNDdfnyZR05ciRTInz48GGlpaVl2vdv9L3My/UWFBSkJ554Qk888YROnz6tO++8Uy+99NINE+7PPvtM/fv31+uvv24tu3jxohITE3MVQ0bbDx06ZHNJ9Z9//pnnlz3XqVNHGzduVHJyss2D077//nvr9KtVqlRJr7zyilq1aqUOHTpo/fr12XoC/rUqVqyohx56SHPmzLHelpEhJ332tT/YXD1/6cqbCrKzT+RVnw4At4pLygEUOs7Ozmrfvr1WrFhhcylvQkKCFi5cqGbNmlkPNM+cOWPzWS8vL1WqVMl6yeU///xjvdQyQ8WKFeXt7Z3lZZk3U79+fQUEBOjdd9+1+fyqVat04MCBTE/OzisbNmzQpEmTVL58eeurxQICAtSqVSvNmTPnupd55tTZs2cznbXLOIDPaG+vXr2UlpamSZMmZfr85cuXb5q0rF+/Psvyr776StL/Xa7v7Owsi8WitLQ0a52jR49q+fLl2WlKjl2+fFlz5syxjqempmrOnDny9/dXvXr1svyMPbZBTkRERKhatWqaO3euzXqaPXu2LBaL7rvvvkyfcXNz09KlS9WgQQN17dpVP/zww02Xk5G8vv3225mmzZo1y6aOdPPvZV6st7S0tEyXfwcEBCg4OPim321nZ+dM+/nMmTNt1mFOtGvXTq6urpo5c6bNfKdPn56r+d3Ifffdp7S0NM2dO9dalpKSoujoaDVq1CjLJ5TXqlVLX331lQ4cOKCuXbtmeW9/dowdO1aXLl3SK6+8YlOekz474weta/uJyMhI6/vjs3p+RMY+kdd9OgDcKs5wAyiwPvjgA61evTpT+VNPPaXJkydr7dq1atasmZ544gm5uLhozpw5SklJsTnYCw8PV6tWrVSvXj2VLFlSO3futL4mSLpyhrJt27bq1auXwsPD5eLiomXLlikhIUG9e/fOccyurq6aNm2aBg4cqJYtW6pPnz7W14KFhYVpxIgRuV8h/9+qVav0yy+/6PLly0pISNCGDRu0du1ahYaGauXKlTaX7s6aNUvNmjVTzZo1NXjwYFWoUEEJCQnatm2bTpw4oR9//DFHy54/f77eeecd3XPPPapYsaLOnTunefPmycfHR506dZJ05T7vxx57TFOmTFFsbKzat28vV1dXHTp0SEuWLNGMGTOyTPQydO/eXeXLl1fXrl1VsWJFXbhwQevWrdP//vc/axIoXXkQ3RtvvKEOHTrowQcf1OnTpzVr1ixVqlTJ5n7gvBIcHKxp06bp6NGjqlKlihYvXqzY2FjNnTv3hq85y8k2yDhTfrP3BSclJVnfk/ztt99KupLs+vn5yc/Pz7p/S9Krr76qbt26qX379urdu7f27dunt99+W48++qj1dUvX8vT01BdffKE2bdqoY8eO2rx5s2rUqHHdeOrUqaNHH31UM2bM0KFDh6yv9lq7dq2++uorPfroo6pdu7a1/s2+lzldb1k5d+6cypYtq/vuu0+1a9eWl5eX1q1bpx07dticuc5Kly5d9OGHH8rX11fh4eHatm2b1q1bp1KlSt3wc9fj7++vZ555xvoquk6dOmnPnj1atWqVSpcuna15bNmyRVu2bJF0Jbm8cOGCJk+eLOnKJfotWrSQdOWhf/fff7/GjBmj06dPq1KlSpo/f76OHj2q999//7rzv+uuu7RixQp16tRJ9913n5YvX37D/TorGWe558+fn2ladvvsOnXqyNnZWdOmTVNSUpLc3d3Vpk0bBQQEaPbs2Xr44Yd15513qnfv3vL399exY8f05ZdfqmnTpnr77bfzvE8HgFvmmIejA8D1Zbxq53rD8ePHjTHG7N6920RGRhovLy9TrFgx07p1a/Pdd9/ZzGvy5MmmYcOGxs/Pz3h6eppq1aqZl156yfoap7/++stERUWZatWqmeLFixtfX1/TqFEj8+mnn2Y7zqxekbV48WJTt25d4+7ubkqWLGn69u1rTpw4YVPnZq9Sutl6cXNzM4GBgebuu+82M2bMsHm11dWOHDli+vXrZwIDA42rq6u54447TJcuXcxnn31207ZkvN4n4xU9u3fvNn369DHlypUz7u7uJiAgwHTp0sXs3Lkz03Lnzp1r6tWrZzw9PY23t7epWbOmee6556yvDrqeTz75xPTu3dtUrFjReHp6Gg8PDxMeHm6ef/75TG18//33TeXKlY27u7upVq2aiY6ONuPHjzfX/vemq15/lCHjFV7Xvj4oq1catWzZ0kRERJidO3eaxo0bGw8PDxMaGmrefvvtLOd59WvBjMneNjDGmNKlS9u8qut6MpaT1RAaGpqp/rJly0ydOnWMu7u7KVu2rBk7dqz1O5Ahq/3xr7/+MuHh4SYwMNAcOnTohjGlpaWZGTNmmNq1axsPDw/j4eFhateubd56661Mr3S72fcyw63suykpKebZZ581tWvXNt7e3qZ48eKmdu3a5p133rlhO4y58mqpgQMHmtKlSxsvLy8TGRlpfvnlFxMaGmrzCq/sfm8y1s/EiRNNUFCQ8fT0NK1atTL79u3LNM/rydivsxrGjx9vU/fff/81zzzzjAkMDDTu7u6mQYMGZvXq1ZnmmdX3YsWKFcbFxcU88MADWb6KL8PVrwW72qFDh4yzs3Om75Ax2euzjTFm3rx5pkKFCtb5XL0eN27caCIjI42vr6/x8PAwFStWNAMGDLD2QbfSpwOAPViMccATPQAAKERatWqlv/76S/v27bPbMvbv36+IiAh98cUXdrv1AAAA5C/u4QYAoADYuHGjGjduTLINAEARwhluAABuIj/OcAMAgKKHM9wAAAAAANgBZ7gBAAAAALADznADAAAAAGAHJNwAAAAAANgBCTcAAAAAAHZAwg0AAAAAgB2QcAMAAAAAYAck3AAAAAAA2AEJNwAAAAAAdkDCDQAAAACAHZBwAwAAAABgByTcAAAAAADYAQk3AAAAAAB2QMINAAAAAIAdkHADAAAAAGAHJNwAAAAAANgBCTcAAAAAAHZAwg0AAAAAgB2QcAMAAAAAYAck3AAAAAAA2AEJNwAAAAAAdkDCDQAAAACAHbg4OoBbkZ6erpMnT8rb21sWi8XR4QAohIwxOnfunIKDg+XkVHR+g6R/BHCrimr/KNFHArg1OekfC3XCffLkSYWEhDg6DABFwPHjx1W2bFlHh5Fn6B8B5JWi1j9K9JEA8kZ2+sdCnXB7e3tLutJQHx8fB0cDoDBKTk5WSEiItT8pKugfAdyqoto/SvSRAG5NTvrHQp1wZ1wC5OPjQ2cJ4JYUtUsK6R8B5JWi1j9K9JEA8kZ2+seidUMOAAAAAAAFBAk3AAAAAAB2QMINAAAAAIAdFOp7uAEAAAAgLxhjdPnyZaWlpTk6FDiYs7OzXFxc8uQZFiTcAAAAAG5rqampOnXqlP755x9Hh4IColixYgoKCpKbm9stzYeEGwAAAMBtKz09XXFxcXJ2dlZwcLDc3NyK5NP5kT3GGKWmpurPP/9UXFycKleuLCen3N+JTcINAAAA4LaVmpqq9PR0hYSEqFixYo4OBwWAp6enXF1d9fvvvys1NVUeHh65nhcPTQOAfDZhwgRZLBaboVq1atbpFy9eVFRUlEqVKiUvLy/17NlTCQkJDowYAPLHlClT1KBBA3l7eysgIEA9evTQwYMHbeq0atUqUx/6n//8x0ERoyi5lbOYKHryan9grwIAB4iIiNCpU6eswzfffGOdNmLECP3vf//TkiVLtHnzZp08eVL33nuvA6MFgPyxefNmRUVFafv27Vq7dq0uXbqk9u3b68KFCzb1Bg8ebNOHvvLKKw6KGABujEvKAcABXFxcFBgYmKk8KSlJ77//vhYuXKg2bdpIkqKjo1W9enVt375dd911V36HCgD5ZvXq1TbjMTExCggI0K5du9SiRQtrebFixbLsQwEUfkePHlX58uW1Z88e1alTp8DOM7s4ww0ADnDo0CEFBwerQoUK6tu3r44dOyZJ2rVrly5duqR27dpZ61arVk3lypXTtm3brju/lJQUJScn2wwAUNglJSVJkkqWLGlT/vHHH6t06dKqUaOGxowZc9MnS9NHoqj6888/9fjjj6tcuXJyd3dXYGCgIiMj9e233+ZrHBaLRcuXL8+35bVq1UrDhw/Pdv2QkBCdOnVKNWrUkCRt2rRJFotFiYmJ9gnwKpzhBpD/JvhKE5IcHYXDNGrUSDExMapatapOnTqliRMnqnnz5tq3b5/i4+Pl5uYmPz8/m8+UKVNG8fHx153nlClTNHHixLwJ8DbfPgAKhvT0dA0fPlxNmza1HiRL0oMPPqjQ0FAFBwfrp59+0qhRo3Tw4EEtXbr0uvPK0z5SUtjoL3V0auc8mx8KrrDRX+br8nK6X/Xs2VOpqamaP3++KlSooISEBK1fv15nzpyxU4S5l5qaesuv2MotZ2dnh10VwxluAMhnHTt21P33369atWopMjJSX331lRITE/Xpp5/mep5jxoxRUlKSdTh+/HgeRgwA+S8qKkr79u3TokWLbMqHDBmiyMhI1axZU3379tWCBQu0bNkyHTly5Lrzoo9EUZSYmKitW7dq2rRpat26tUJDQ9WwYUONGTNG3bp1s9azWCyaPXu2OnbsKE9PT1WoUEGfffaZzbyOHz+uXr16yc/PTyVLllT37t119OhRmzoffPCBIiIi5O7urqCgIA0dOlSSFBYWJkm65557ZLFYrOMTJkxQnTp19N5776l8+fLWJ32vXr1azZo1k5+fn0qVKqUuXbrc8PubHWFhYXr55Zf1yCOPyNvbW+XKldPcuXOt048ePSqLxaLY2FgdPXpUrVu3liSVKFFCFotFAwYMuKXl3wgJNwA4mJ+fn6pUqaLDhw8rMDBQqampmS5xSkhIuOEvs+7u7vLx8bEZAKCwGjp0qL744gtt3LhRZcuWvWHdRo0aSZIOHz583Tr0kSiKvLy85OXlpeXLlyslJeWGdceNG6eePXvqxx9/VN++fdW7d28dOHBAknTp0iVFRkbK29tbW7du1bfffisvLy916NBBqampkqTZs2crKipKQ4YM0d69e7Vy5UpVqlRJkrRjxw5JV545c+rUKeu4dOV7+fnnn2vp0qWKjY2VJF24cEEjR47Uzp07tX79ejk5Oemee+5Renr6La2P119/XfXr19eePXv0xBNP6PHHH8/0lgPpyuXln3/+uSTp4MGDOnXqlGbMmHFLy74REm4AcLDz58/ryJEjCgoKUr169eTq6qr169dbpx88eFDHjh1T48aNHRglANifMUZDhw7VsmXLtGHDBpUvX/6mn8k4iA8KCrJzdEDB4uLiopiYGM2fP19+fn5q2rSp/vvf/+qnn37KVPf+++/Xo48+qipVqmjSpEmqX7++Zs6cKUlavHix0tPT9d5776lmzZqqXr26oqOjdezYMW3atEmSNHnyZD399NN66qmnVKVKFTVo0MB6D7W/v7+kKycQAgMDrePSlcvIFyxYoLp166pWrVqSrlwGf++996pSpUqqU6eOPvjgA+3du1f79++/pfXRqVMnPfHEE6pUqZJGjRql0qVLa+PGjZnqOTs7W58LERAQoMDAQPn6+t7Ssm+EhBsA8tkzzzyjzZs36+jRo/ruu+90zz33yNnZWX369JGvr68GDRqkkSNHauPGjdq1a5cGDhyoxo0b84RyAEVeVFSUPvroIy1cuFDe3t6Kj49XfHy8/v33X0nSkSNHNGnSJO3atUtHjx7VypUr1a9fP7Vo0cJ6MA/cTnr27KmTJ09q5cqV6tChgzZt2qQ777xTMTExNvWu/dG+cePG1jPcP/74ow4fPixvb2/rWfOSJUvq4sWLOnLkiE6fPq2TJ0+qbdu2OY4vNDTUJgGXrjw4tk+fPqpQoYJ8fHysl6BnPEA2t67uAywWiwIDA3X69Olbmmde4KFpAJDPTpw4oT59+ujMmTPy9/dXs2bNtH37dut/SG+++aacnJzUs2dPpaSkKDIyUu+8846DowYA+5s9e7akK08gvlp0dLQGDBggNzc3rVu3TtOnT9eFCxcUEhKinj17auzYsQ6IFigYPDw8dPfdd+vuu+/WuHHj9Oijj2r8+PHZvi/5/Pnzqlevnj7++ONM0/z9/eXklPtztMWLF89U1rVrV4WGhmrevHkKDg5Wenq6atSoYb18PbdcXV1txi0Wyy1fpp4XSLgBIJ9d+wCga3l4eGjWrFmaNWtWPkUEAAWDMeaG00NCQrR58+Z8igYonMLDwzO9omv79u3q16+fzXjdunUlSXfeeacWL16sgICA6z7fICwsTOvXr7c+bOxarq6uSktLu2lsZ86c0cGDBzVv3jw1b95ckvTNN99kp1l5KuNp6dmJ+VZxSTkAAAAAFDJnzpxRmzZt9NFHH+mnn35SXFyclixZoldeeUXdu3e3qbtkyRJ98MEH+vXXXzV+/Hj98MMP1qeM9+3bV6VLl1b37t21detWxcXFadOmTXryySd14sQJSVeeOP7666/rrbfe0qFDh7R7927rPeDS/yXk8fHxOnv27HVjLlGihEqVKqW5c+fq8OHD2rBhg0aOHGmHtXNjoaGhslgs+uKLL/Tnn3/q/PnzdlsWCTcAAAAAFDJeXl5q1KiR3nzzTbVo0UI1atTQuHHjNHjwYL399ts2dSdOnKhFixapVq1aWrBggT755BOFh4dLkooVK6YtW7aoXLlyuvfee1W9enUNGjRIFy9etJ7x7t+/v6ZPn6533nlHERER6tKliw4dOmSd/+uvv661a9cqJCTEeuY8K05OTlq0aJF27dqlGjVqaMSIEXr11VftsHZu7I477tDEiRM1evRolSlTxvrjgz1YzM2u3SnAkpOT5evrq6SkJF7vABQmE3ylCUmOjkJS0e1HbqldBWj7AHCcoto/SrfetrDRX+ro1M52iAyOcPHiRcXFxdm8K7oosVgsWrZsmXr06OHoUAqVG+0XOelDOMMNAAAAAIAdkHADAAAAAGAHPKUcAAAAAIqoQnwHcZHAGW4AAAAAAOyAhBsAAAAAADsg4QYAAAAAwA5IuAEAAAAAsAMSbgAAAAAA7ICEGwAAAAAAOyDhBgAAAIDbXFhYmKZPn24dj4+P1913363ixYvLz8/PYXHdipiYGIfHznu4AQAAACArE3zzeXlJOareqlUr1alTxyZRlq4kmsOHD1diYmK257Vjxw4VL17cOv7mm2/q1KlTio2Nla9vPq+H67BYLFq2bJl69OiRrfoPPPCAOnXqZB2fMGGCli9frtjYWPsEmAUSbgAAAAC4zfn7+9uMHzlyRPXq1VPlypVzPc/U1FS5ubndami55unpKU9PT4ctX+KScgAAAAAo0gYMGKAePXrotddeU1BQkEqVKqWoqChdunTJWufqS8rDwsL0+eefa8GCBbJYLBowYIAk6dixY+revbu8vLzk4+OjXr16KSEhwTqPCRMmqE6dOnrvvfdUvnx5eXh4SLpyZnrOnDnq0qWLihUrpurVq2vbtm06fPiwWrVqpeLFi6tJkyY6cuRIttt09OhRWSwWLV26VK1bt1axYsVUu3Ztbdu2zVrn6kvKY2JiNHHiRP3444+yWCyyWCyKiYnJ3QrNARJuAAAAACjiNm7cqCNHjmjjxo2aP3++YmJirptw7tixQx06dFCvXr106tQpzZgxQ+np6erevbv+/vtvbd68WWvXrtVvv/2mBx54wOazhw8f1ueff66lS5faXLo9adIk9evXT7GxsapWrZoefPBBPfbYYxozZox27twpY4yGDh2a43Y9//zzeuaZZxQbG6sqVaqoT58+unz5cqZ6DzzwgJ5++mlFRETo1KlTOnXqVKbY7YFLygEAAACgiCtRooTefvttOTs7q1q1aurcubPWr1+vwYMHZ6rr7+8vd3d3eXp6KjAwUJK0du1a7d27V3FxcQoJCZEkLViwQBEREdqxY4caNGgg6cpl5AsWLMh0ifrAgQPVq1cvSdKoUaPUuHFjjRs3TpGRkZKkp556SgMHDsxxu5555hl17txZkjRx4kRFRETo8OHDqlatmk09T09PeXl5ycXFxdqm/MAZbgAAAAAo4iIiIuTs7GwdDwoK0unTp7P9+QMHDigkJMSabEtSeHi4/Pz8dODAAWtZaGhopmRbkmrVqmX9u0yZMpKkmjVr2pRdvHhRycnJ2Y7p2vkGBQVJUo7aZW8k3AAAAABQCPn4+CgpKfOTzRMTEzM9WdzV1dVm3GKxKD09Pc9juvpJ59dbvsViuW5ZTmPKi3nYEwk3AAAAABRCVatW1e7duzOV7969W1WqVMnTZVWvXl3Hjx/X8ePHrWX79+9XYmKiwsPD83RZ9uLm5qa0tLR8XSYJNwAAAAAUQo8//rh+/fVXPfnkk/rpp5908OBBvfHGG/rkk0/09NNP5+my2rVrp5o1a6pv377avXu3fvjhB/Xr108tW7ZU/fr183RZ9hIWFqa4uDjFxsbqr7/+UkpKit2X6dCEOy0tTePGjVP58uXl6empihUratKkSTLGODIsAAAAACjwKlSooC1btuiXX35Ru3bt1KhRI3366adasmSJOnTokKfLslgsWrFihUqUKKEWLVqoXbt2qlChghYvXpyny7Gnnj17qkOHDmrdurX8/f31ySef2H2ZFuPA7Pbll1/WG2+8ofnz5ysiIkI7d+7UwIED9dJLL+nJJ5+86eeTk5Pl6+urpKQk+fj45EPEAPLEBF9pQub7jRyhqPYjt9SuArR9ADhOUe0fpVtvW9joL3V0amc7RAZHuHjxouLi4mzeGw3caL/ISR/i0NeCfffdd+revbv1Me5hYWH65JNP9MMPPzgyLAAAAAAAbplDLylv0qSJ1q9fr19//VWS9OOPP+qbb75Rx44ds6yfkpKi5ORkmwEAAAAAgILIoWe4R48ereTkZFWrVk3Ozs5KS0vTSy+9pL59+2ZZf8qUKZo4cWI+RwkAAAAAQM459Az3p59+qo8//lgLFy7U7t27NX/+fL322muaP39+lvXHjBmjpKQk63D1I+kBAAAAAChIHHqG+9lnn9Xo0aPVu3dvSVLNmjX1+++/a8qUKerfv3+m+u7u7nJ3d8/vMAEAAAAAyDGHnuH+559/5ORkG4Kzs7PS09MdFBEAAACA2xGvJsbV8mp/cOgZ7q5du+qll15SuXLlFBERoT179uiNN97QI4884siwAAAAANwmXF1dJV05Gejp6engaFBQ/PPPP5L+b//ILYcm3DNnztS4ceP0xBNP6PTp0woODtZjjz2mF154wZFhAQAAALhNODs7y8/PT6dPn5YkFStWTBaLxcFRwVGMMfrnn390+vRp+fn5ydnZ+Zbm59CE29vbW9OnT9f06dMdGQYAAACA21hgYKAkWZNuwM/Pz7pf3AqHJtwAAAAA4GgWi0VBQUEKCAjQpUuXHB0OHMzV1fWWz2xnIOEGAAAAAF25vDyvEi1AcvBTygEAAAAAKKpIuAEAAAAAsAMSbgAAAAAA7ICEGwAAAAAAOyDhBgAAAADADki4AQAAAACwAxJuAAAAAADsgIQbAAAAAAA7IOEGAAAAAMAOSLgBAAAAALADEm4AAAAAAOyAhBsAAAAAADsg4QYAAAAAwA5IuAHAwaZOnSqLxaLhw4dbyy5evKioqCiVKlVKXl5e6tmzpxISEhwXJADkgylTpqhBgwby9vZWQECAevTooYMHD9rUoX8EUJiQcAOAA+3YsUNz5sxRrVq1bMpHjBih//3vf1qyZIk2b96skydP6t5773VQlACQPzZv3qyoqCht375da9eu1aVLl9S+fXtduHDBWof+EUBh4uLoAADgdnX+/Hn17dtX8+bN0+TJk63lSUlJev/997Vw4UK1adNGkhQdHa3q1atr+/btuuuuuxwVMgDY1erVq23GY2JiFBAQoF27dqlFixb0jwAKHc5wA4CDREVFqXPnzmrXrp1N+a5du3Tp0iWb8mrVqqlcuXLatm1blvNKSUlRcnKyzQAAhV1SUpIkqWTJkpJy1z9K9JEAHIeEGwAcYNGiRdq9e7emTJmSaVp8fLzc3Nzk5+dnU16mTBnFx8dnOb8pU6bI19fXOoSEhNgjbADIN+np6Ro+fLiaNm2qGjVqSMpd/yjRRwJwHBJuAMhnx48f11NPPaWPP/5YHh4eeTLPMWPGKCkpyTocP348T+YLAI4SFRWlffv2adGiRbc8L/pIAI7CPdwAkM927dql06dP684777SWpaWlacuWLXr77be1Zs0apaamKjEx0eYsTkJCggIDA7Ocp7u7u9zd3e0dOgDki6FDh+qLL77Qli1bVLZsWWt5YGBgjvtHiT4SgONwhhsA8lnbtm21d+9excbGWof69eurb9++1r9dXV21fv1662cOHjyoY8eOqXHjxg6MHADsyxijoUOHatmyZdqwYYPKly9vM71evXr0jwAKFc5wA0A+8/b2tt6PmKF48eIqVaqUtXzQoEEaOXKkSpYsKR8fHw0bNkyNGzfmCbwAirSoqCgtXLhQK1askLe3t/W+bF9fX3l6esrX15f+EUChQsINAAXQm2++KScnJ/Xs2VMpKSmKjIzUO++84+iwAMCuZs+eLUlq1aqVTXl0dLQGDBggif4RQOFCwg0ABcCmTZtsxj08PDRr1izNmjXLMQEBgAMYY25ah/4RQGHCPdwA8t4EX0dHAAAAADgcCTcAAAAAAHZAwg0AAAAAgB2QcAMAAAAAYAck3AAAAAAA2AEJNwAAAAAAdkDCDQAAAACAHZBwAwAAAABgByTcAAAAAADYAQk3AAAAAAB2QMINAAAAAIAdkHADAAAAAGAHJNwAAAAAANgBCTcAAAAAAHZAwg0AAAAAgB2QcAMAAAAAYAck3AAAAAAA2AEJNwAAAAAAdkDCDQAAAACAHZBwAwAAAABgByTcAAAAAADYAQk3AAAAAAB2QMINAAAAAIAdkHADAAAAAGAHJNwAAAAAANgBCTcAAAAAAHZAwg0AAAAAgB2QcAMAAAAAYAcOT7j/+OMPPfTQQypVqpQ8PT1Vs2ZN7dy509FhAQAAAABwS1wcufCzZ8+qadOmat26tVatWiV/f38dOnRIJUqUcGRYAAAAAADcMocm3NOmTVNISIiio6OtZeXLl3dgRAAAAAAA5A2HXlK+cuVK1a9fX/fff78CAgJUt25dzZs377r1U1JSlJycbDMAAAAAAFAQOTTh/u233zR79mxVrlxZa9as0eOPP64nn3xS8+fPz7L+lClT5Ovrax1CQkLyOWIAeWqC761NBwAAAAowhybc6enpuvPOO/Xyyy+rbt26GjJkiAYPHqx33303y/pjxoxRUlKSdTh+/Hg+RwwAAAAAQPY4NOEOCgpSeHi4TVn16tV17NixLOu7u7vLx8fHZgAAAAAAoCByaMLdtGlTHTx40Kbs119/VWhoqIMiAgAAAAAgbzg04R4xYoS2b9+ul19+WYcPH9bChQs1d+5cRUVFOTIsAAAAAABumUMT7gYNGmjZsmX65JNPVKNGDU2aNEnTp09X3759HRkWAAAAAAC3zKHv4ZakLl26qEuXLo4OAwAAAACAPOXQM9wAAAAAABRVJNwAAAAAANgBCTcAAAAAAHZAwg0AAAAAgB2QcAMAAAAAYAck3AAAAAAA2AEJNwAAAAAAdkDCDQAAAACAHZBwAwAAAABgByTcAJDPZs+erVq1asnHx0c+Pj5q3LixVq1aZZ1+8eJFRUVFqVSpUvLy8lLPnj2VkJDgwIgBIP9s2bJFXbt2VXBwsCwWi5YvX24zfcCAAbJYLDZDhw4dHBMsANwECTcA5LOyZctq6tSp2rVrl3bu3Kk2bdqoe/fu+vnnnyVJI0aM0P/+9z8tWbJEmzdv1smTJ3Xvvfc6OGoAyB8XLlxQ7dq1NWvWrOvW6dChg06dOmUdPvnkk3yMEACyz8XRAQDA7aZr16424y+99JJmz56t7du3q2zZsnr//fe1cOFCtWnTRpIUHR2t6tWra/v27brrrrscETIA5JuOHTuqY8eON6zj7u6uwMDAfIoIAHKPM9wA4EBpaWlatGiRLly4oMaNG2vXrl26dOmS2rVrZ61TrVo1lStXTtu2bbvufFJSUpScnGwzAEBRtWnTJgUEBKhq1ap6/PHHdebMmRvWp48E4Cgk3ADgAHv37pWXl5fc3d31n//8R8uWLVN4eLji4+Pl5uYmPz8/m/plypRRfHz8dec3ZcoU+fr6WoeQkBA7twAomMJGf+noEGBnHTp00IIFC7R+/XpNmzZNmzdvVseOHZWWlnbdz9irj2R/A3AzXFIOAA5QtWpVxcbGKikpSZ999pn69++vzZs353p+Y8aM0ciRI63jycnJJN0AiqTevXtb/65Zs6Zq1aqlihUratOmTWrbtm2Wn6GPBOAoJNwA4ABubm6qVKmSJKlevXrasWOHZsyYoQceeECpqalKTEy0OcudkJBww/sV3d3d5e7ubu+wAaDAqVChgkqXLq3Dhw9fN+GmjwTgKFxSDgAFQHp6ulJSUlSvXj25urpq/fr11mkHDx7UsWPH1LhxYwdGCAAF04kTJ3TmzBkFBQU5OhQAyCRXZ7grVKigHTt2qFSpUjbliYmJuvPOO/Xbb7/lSXAAUBSNGTNGHTt2VLly5XTu3DktXLhQmzZt0po1a+Tr66tBgwZp5MiRKlmypHx8fDRs2DA1btyYJ5QDuC2cP39ehw8fto7HxcUpNjZWJUuWVMmSJTVx4kT17NlTgYGBOnLkiJ577jlVqlRJkZGRDowaALKWq4T76NGjWT6YIiUlRX/88cctBwUARdnp06fVr18/nTp1Sr6+vqpVq5bWrFmju+++W5L05ptvysnJST179lRKSooiIyP1zjvvODhqAMgfO3fuVOvWra3jGfde9+/fX7Nnz9ZPP/2k+fPnKzExUcHBwWrfvr0mTZrEJeMACqQcJdwrV660/p1xJiZDWlqa1q9fr7CwsDwLDgCKovfff/+G0z08PDRr1izNmjUrnyICgIKjVatWMsZcd/qaNWvyMRoAuDU5Srh79OghSbJYLOrfv7/NNFdXV4WFhen111/Ps+AAAAAAACiscpRwp6enS5LKly+vHTt2qHTp0nYJCgAAAACAwi5X93DHxcXldRwAAAAAABQpuX4P9/r167V+/XqdPn3aeuY7wwcffHDLgQEAAAAAUJjlKuGeOHGiXnzxRdWvX19BQUGyWCx5HRcAAAAAAIVarhLud999VzExMXr44YfzOh4AAAAAAIoEp9x8KDU1VU2aNMnrWAAgaxN8b1olbPSX+RAIAAAAkH25SrgfffRRLVy4MK9jAQAAAACgyMjVJeUXL17U3LlztW7dOtWqVUuurq4209944408CQ4AAAAAgMIqVwn3Tz/9pDp16kiS9u3bZzONB6gBAAAAAJDLhHvjxo15HQcAAAAAAEVKru7hBgAAAAAAN5arM9ytW7e+4aXjGzZsyHVAAAAAAAAUBblKuDPu385w6dIlxcbGat++ferfv39exAUAAAAAQKGWq4T7zTffzLJ8woQJOn/+/C0FBAAAAABAUZCn93A/9NBD+uCDD/JylgAAAAAAFEp5mnBv27ZNHh4eeTlLAAAAAAAKpVxdUn7vvffajBtjdOrUKe3cuVPjxo3Lk8AAAAAAACjMcpVw+/r62ow7OTmpatWqevHFF9W+ffs8CQwAAAAAgMIsVwl3dHR0XscBAAAAAECRkquEO8OuXbt04MABSVJERITq1q2bJ0EBAAAAAFDY5SrhPn36tHr37q1NmzbJz89PkpSYmKjWrVtr0aJF8vf3z8sYAQAAAAAodHL1lPJhw4bp3Llz+vnnn/X333/r77//1r59+5ScnKwnn3wyr2MEAAAAAKDQydUZ7tWrV2vdunWqXr26tSw8PFyzZs3ioWkAAAAAACiXZ7jT09Pl6uqaqdzV1VXp6em3HBQAAAAAAIVdrhLuNm3a6KmnntLJkyetZX/88YdGjBihtm3b5llwAAAAAAAUVrlKuN9++20lJycrLCxMFStWVMWKFVW+fHklJydr5syZeR0jAAAAAACFTq7u4Q4JCdHu3bu1bt06/fLLL5Kk6tWrq127dnkaHAAAAAAAhVWOznBv2LBB4eHhSk5OlsVi0d13361hw4Zp2LBhatCggSIiIrR161Z7xQoAAAAAQKGRo4R7+vTpGjx4sHx8fDJN8/X11WOPPaY33ngjz4IDAAAAAKCwylHC/eOPP6pDhw7Xnd6+fXvt2rXrloMCAAAAAKCwy1HCnZCQkOXrwDK4uLjozz//vOWgAAAAAAAo7HKUcN9xxx3at2/fdaf/9NNPCgoKuuWgAAAAAAAo7HKUcHfq1Enjxo3TxYsXM037999/NX78eHXp0iXPggMAAAAAoLDKUcI9duxY/f3336pSpYpeeeUVrVixQitWrNC0adNUtWpV/f3333r++edzFcjUqVNlsVg0fPjwXH0eAAAAAICCJEfv4S5Tpoy+++47Pf744xozZoyMMZIki8WiyMhIzZo1S2XKlMlxEDt27NCcOXNUq1atHH8WAAAAAICCKEcJtySFhobqq6++0tmzZ3X48GEZY1S5cmWVKFEiVwGcP39effv21bx58zR58uRczQMAAAAAgIImR5eUX61EiRJq0KCBGjZsmOtkW5KioqLUuXNntWvX7qZ1U1JSlJycbDMAAAAAAFAQ5TrhzguLFi3S7t27NWXKlGzVnzJlinx9fa1DSEiInSMEUNCFjf7S0SEAAAAAWXJYwn38+HE99dRT+vjjj+Xh4ZGtz4wZM0ZJSUnW4fjx43aOEgAAAACA3MnxPdx5ZdeuXTp9+rTuvPNOa1laWpq2bNmit99+WykpKXJ2drb5jLu7u9zd3fM7VAAAAAAAcsxhCXfbtm21d+9em7KBAweqWrVqGjVqVKZkGwAAAACAwsRhCbe3t7dq1KhhU1a8eHGVKlUqUzkAAAAAAIWNQx+aBgAAAABAUeWwM9xZ2bRpk6NDAAAAAAAgT3CGGwAAAAAAOyDhBgAAAADADki4ASCfTZkyRQ0aNJC3t7cCAgLUo0cPHTx40KbOxYsXFRUVpVKlSsnLy0s9e/ZUQkKCgyIGgPyzZcsWde3aVcHBwbJYLFq+fLnNdGOMXnjhBQUFBcnT01Pt2rXToUOHHBMsANwECTcA5LPNmzcrKipK27dv19q1a3Xp0iW1b99eFy5csNYZMWKE/ve//2nJkiXavHmzTp48qXvvvdeBUQNA/rhw4YJq166tWbNmZTn9lVde0VtvvaV3331X33//vYoXL67IyEhdvHgxnyMFgJsrUA9NA4DbwerVq23GY2JiFBAQoF27dqlFixZKSkrS+++/r4ULF6pNmzaSpOjoaFWvXl3bt2/XXXfd5YiwASBfdOzYUR07dsxymjFG06dP19ixY9W9e3dJ0oIFC1SmTBktX75cvXv3zs9QAeCmOMMNAA6WlJQkSSpZsqQkadeuXbp06ZLatWtnrVOtWjWVK1dO27Zty3IeKSkpSk5OthkAoKiJi4tTfHy8Tf/o6+urRo0aXbd/lOgjATgOCTcAOFB6erqGDx+upk2bqkaNGpKk+Ph4ubm5yc/Pz6ZumTJlFB8fn+V8pkyZIl9fX+sQEhJi79ABIN9l9IFlypSxKb9R/yjRRwK3vQm+Wf+dD0i4AcCBoqKitG/fPi1atOiW5jNmzBglJSVZh+PHj+dRhABQ+NFHAnAU7uEGAAcZOnSovvjiC23ZskVly5a1lgcGBio1NVWJiYk2Z7kTEhIUGBiY5bzc3d3l7u5u75ABwKEy+sCEhAQFBQVZyxMSElSnTp3rfo4+EoCjcIYbAPKZMUZDhw7VsmXLtGHDBpUvX95mer169eTq6qr169dbyw4ePKhjx46pcePG+R0uABQY5cuXV2BgoE3/mJycrO+//57+EUCBxBluAMhnUVFRWrhwoVasWCFvb2/rfYe+vr7y9PSUr6+vBg0apJEjR6pkyZLy8fHRsGHD1LhxY55QDqDIO3/+vA4fPmwdj4uLU2xsrEqWLKly5cpp+PDhmjx5sipXrqzy5ctr3LhxCg4OVo8ePRwXNABcBwk3AOSz2bNnS5JatWplUx4dHa0BAwZIkt588005OTmpZ8+eSklJUWRkpN555518jhQA8t/OnTvVunVr6/jIkSMlSf3791dMTIyee+45XbhwQUOGDFFiYqKaNWum1atXy8PDw1EhA8B1kXADQD4zxty0joeHh2bNmqVZs2blQ0QAUHC0atXqhv2kxWLRiy++qBdffDEfowKA3OEebgAAAAAA7ICEGwAAAAAAOyDhBgAAAADADki4AQAAAACwAxJuAAAAAADsgIQbAAAAAAA7IOEGAAAAAMAOSLgBAAAAALADEm4AAAAAAOyAhBsAAAAAADsg4QYAAAAAwA5IuAEAQKEWNvpLR4cAAECWSLgBAAAAALADEm4ADhc2+ktpgu+Vkf//L2esAAAAUNiRcAMAAAAAYAck3AAAAAAA2AEJNwAAAAAAdkDCDQAAAACAHZBwAwAAAABgByTcAAAAAADYAQk3AAAAAAB2QMINAAAAAIAdkHADAAAAAGAHJNwAAAAAANgBCTcAAAAAAHZAwg0AAAAAgB2QcAMAAAAAYAck3AAAAAAA2AEJNwAAAAAAdkDCDQAAANxE2OgvHR0CgJya4OvoCEi4AQAAAACwBxJuAAAAAADsgIQbAAAAAAA7IOEGAAAAAMAOSLgBAAAAALADEm4AAAAAAOyAhBsAAAAAADsg4QYAAAAAwA5IuAEAAAAAsAMSbgAAAAAA7ICEGwAAAABQuE3wtf03u/XtzKEJ95QpU9SgQQN5e3srICBAPXr00MGDBx0ZEgAAAAAAecKhCffmzZsVFRWl7du3a+3atbp06ZLat2+vCxcuODIsAAAAAABumYsjF7569Wqb8ZiYGAUEBGjXrl1q0aKFg6ICAAAAAODWFah7uJOSkiRJJUuWdHAkAAAAAADcGoee4b5aenq6hg8frqZNm6pGjRpZ1klJSVFKSop1PDk5Ob/CAwAAAAAgRwrMGe6oqCjt27dPixYtum6dKVOmyNfX1zqEhITkY4QAbiqrpz3e4hMgw0Z/meXfAAAAQEFXIBLuoUOH6osvvtDGjRtVtmzZ69YbM2aMkpKSrMPx48fzMUoAAAAAALLPoQm3MUZDhw7VsmXLtGHDBpUvX/6G9d3d3eXj42MzAEBhtGXLFnXt2lXBwcGyWCxavny5zXRjjF544QUFBQXJ09NT7dq106FDhxwTLAAUIBMmTJDFYrEZqlWr5uiwACBLDk24o6Ki9NFHH2nhwoXy9vZWfHy84uPj9e+//zoyLACwuwsXLqh27dqaNWtWltNfeeUVvfXWW3r33Xf1/fffq3jx4oqMjNTFixfzOVIAKHgiIiJ06tQp6/DNN984OiQAyJJDH5o2e/ZsSVKrVq1syqOjozVgwID8DwgA8knHjh3VsWPHLKcZYzR9+nSNHTtW3bt3lyQtWLBAZcqU0fLly9W7d+/8DBUAChwXFxcFBgY6OgwAuCmHJtzGGEcuHgAKpLi4OMXHx6tdu3bWMl9fXzVq1Ejbtm3LMuHmLQ4AbieHDh1ScHCwPDw81LhxY02ZMkXlypW7bn36SACOUiAemgYA+D/x8fGSpDJlytiUlylTxjrtWrzFAcDtolGjRoqJidHq1as1e/ZsxcXFqXnz5jp37tx1P0MfCcBRSLgBoAjgLQ4AbhcdO3bU/fffr1q1aikyMlJfffWVEhMT9emnn173M/SRABzFoZeUAwAyy7gvMSEhQUFBQdbyhIQE1alTJ8vPuLu7y93dPT/CA4ACxc/PT1WqVNHhw4evW4c+EoCjcIYbAAqY8uXLKzAwUOvXr7eWJScn6/vvv1fjxo0dGBkAFDznz5/XkSNHbH6gBICCgjPcAOAA58+ftzkbExcXp9jYWJUsWVLlypXT8OHDNXnyZFWuXFnly5fXuHHjFBwcrB49ejguaAAoAJ555hl17dpVoaGhOnnypMaPHy9nZ2f16dPH0aEBQCYk3ADgADt37lTr1q2t4yNHjpQk9e/fXzExMXruued04cIFDRkyRImJiWrWrJlWr14tDw8PR4UMAAXCiRMn1KdPH505c0b+/v5q1qyZtm/fLn9/f0eHBgCZkHADgAO0atXqhq9GtFgsevHFF/Xiiy/mY1QAUPAtWrTI0SEAQLZxDzcAAAAAAHZAwg0AAAAAgB2QcAMAAAAAYAck3AAAAAAA2AEJNwAAAAAAdkDCDQAAAACAHZBwAwAAAABgByTcAAAAAADYAQk3AAAAAAB2QMINAAAAAIAdkHADAAAAAGAHJNwAAAAAANgBCTcAAAAAAHZAwg0AAAAAgB2QcAMAAAAAYAck3AAAAAAA2AEJNwAAAAAAdkDCDQAAAAC4fU3wtdusSbgBAAAAALADEm4A2Zfx619ufgW85jNho7/MdQxho7+0nZ8df5UEAAAAcouEGwAAAAAAOyDhBgAAAADADki4AQAAAACwAxJuAAAAAADsgIQbAAAAAAA7IOEGAAAAAMAOSLgBAAAAALADEm4AAAAAAOyAhBsAAAC4RWGjv3R0CAAKIBJuAAAAAADsgIQbAAAAAAA7IOEGAAAAAMAOSLgBAAAAALADEm4AAAAAAOyAhBsAAAAAADsg4QYAAAAAwA5IuAEAAAAAsAMSbgAAAAAA7ICEGwAAAAAAOyDhBgAAAADADki4AQBAkRM2+ktHhwAUSHw3UCRM8LX9twAj4QYAAAAAwA5IuAEAAAAAsAMSbgAAAAAA7ICEGwAAAAAAOyDhBgAAAADADki4AQAAijCeSg0AjkPCDQAAAACAHRSIhHvWrFkKCwuTh4eHGjVqpB9++MHRIQFAgUD/CABZo38EUBg4POFevHixRo4cqfHjx2v37t2qXbu2IiMjdfr0aUeHBgAORf8IAFmjfwRQWDg84X7jjTc0ePBgDRw4UOHh4Xr33XdVrFgxffDBB44ODQAciv4RALJG/wigsHBx5MJTU1O1a9cujRkzxlrm5OSkdu3aadu2bZnqp6SkKCUlxTqelJQkSUpOTrZ/sACkFCMlJ//fv9mZfp2y9JR/lGy5Unb13xn1Msqyqnfdslz0BRmfMcbkdq3YhUP7x+ttX6CAuvr7n/F3bvuEouh27x+lvOkjb7afFZZ9rrDECdxQDo45c1SWTTnqH40D/fHHH0aS+e6772zKn332WdOwYcNM9cePH28kMTAwMOT5cPz48fzq+rKF/pGBgaGgDIW9fzSGPpKBgcE+Q3b6R4ee4c6pMWPGaOTIkdbx9PR0/f333ypVqpQsFstNP5+cnKyQkBAdP35cPj4+9gy1wLld2067b692SzlvuzFG586dU3BwcD5EZz856R9v5/0jN1hfOcc6y7mCuM6KSv8o3foxZEFUEPcZe6PNtLmgyEn/6NCEu3Tp0nJ2dlZCQoJNeUJCggIDAzPVd3d3l7u7u02Zn59fjpfr4+NTYDeevd2ubafdt5+ctN3X19fO0eRcfvSPt/P+kRusr5xjneVcQVtnRaF/lPLuGLIgKmj7TH6gzbeHgt7m7PaPDn1ompubm+rVq6f169dby9LT07V+/Xo1btzYgZEBgGPRPwJA1ugfARQmDr+kfOTIkerfv7/q16+vhg0bavr06bpw4YIGDhzo6NAAwKHoHwEga/SPAAoLhyfcDzzwgP7880+98MILio+PV506dbR69WqVKVMmz5fl7u6u8ePHZ7qk6HZwu7addt9e7ZaKVtvt1T8WpXWUH1hfOcc6yznWWc7k5/FjQXU77jO0+fZQ1NpsMaaAvesBAAAAAIAiwKH3cAMAAAAAUFSRcAMAAAAAYAck3AAAAAAA2AEJNwAAAAAAdlCgEu5Zs2YpLCxMHh4eatSokX744Ycb1l+yZImqVasmDw8P1axZU1999ZXNdGOMXnjhBQUFBcnT01Pt2rXToUOHbOr8/fff6tu3r3x8fOTn56dBgwbp/Pnz1ukHDx5U69atVaZMGXl4eKhChQoaO3asLl26lKNYimK7Y2JiZLFYbAYPD49C3e6rHT58WN7e3vLz88txLEW17UVxmx89ejRTmywWi7Zv356jWBwpL9frpUuXNGrUKNWsWVPFixdXcHCw+vXrp5MnT9q7Gfkqr/fFq/3nP/+RxWLR9OnT8zhqx7LHOjtw4IC6desmX19fFS9eXA0aNNCxY8fs1YR8ldfr6/z58xo6dKjKli0rT09PhYeH691337VnE+AAOdlv5s2bp+bNm6tEiRIqUaKE2rVrl6n+gAEDMv3/1qFDB3s3I9ty0t6lS5eqfv368vPzU/HixVWnTh19+OGHNnWyc1zgaHnd5oK+jaWc94cZFi1aJIvFoh49etiUF4btbMMUEIsWLTJubm7mgw8+MD///LMZPHiw8fPzMwkJCVnW//bbb42zs7N55ZVXzP79+83YsWONq6ur2bt3r7XO1KlTja+vr1m+fLn58ccfTbdu3Uz58uXNv//+a63ToUMHU7t2bbN9+3azdetWU6lSJdOnTx/r9CNHjpgPPvjAxMbGmqNHj5oVK1aYgIAAM2bMmBzFUhTbHR0dbXx8fMypU6esQ3x8/E3bXJDbnSE1NdXUr1/fdOzY0fj6+uY4lqLa9qK4zePi4owks27dOpt2paam5igWR8nr9ZqYmGjatWtnFi9ebH755Rezbds207BhQ1OvXr38bJZd2WNfzLB06VJTu3ZtExwcbN588007tyT/2GOdHT582JQsWdI8++yzZvfu3ebw4cNmxYoV151nYWKP9TV48GBTsWJFs3HjRhMXF2fmzJljnJ2dzYoVK/KrWbCznO43Dz74oJk1a5bZs2ePOXDggBkwYIDx9fU1J06csNbp37+/6dChg83/b3///Xd+NemGctrejRs3mqVLl5r9+/ebw4cPm+nTpxtnZ2ezevVqa53sHBc4kj3aXJC3sTE5b3OGuLg4c8cdd5jmzZub7t2720wr6Nv5WgUm4W7YsKGJioqyjqelpZng4GAzZcqULOv36tXLdO7c2aasUaNG5rHHHjPGGJOenm4CAwPNq6++ap2emJho3N3dzSeffGKMMWb//v1GktmxY4e1zqpVq4zFYjF//PHHdWMdMWKEadasWbZjuZHC3O7o6OhMCVl2FfR2P/fcc+ahhx7Kso23sr0Le9uL4jbPSLj37Nlz3dhvdZvbU16v16z88MMPRpL5/fff8yZoB7PXOjtx4oS54447zL59+0xoaGiRSrjtsc4eeOAB89BDD9knYAezx/qKiIgwL774ok2dO++80zz//PN5GDkcKaf7zbUuX75svL29zfz5861l/fv3z5SsFBS32l5jjKlbt64ZO3asMSZ7xwWOltdtNqZgb2Njctfmy5cvmyZNmpj33nsvU/sKw3a+VoG4pDw1NVW7du1Su3btrGVOTk5q166dtm3bluVntm3bZlNfkiIjI6314+LiFB8fb1PH19dXjRo1stbZtm2b/Pz8VL9+fWuddu3aycnJSd9//32Wyz18+LBWr16tli1bZjuWotpu6colbqGhoQoJCVH37t31888/37DNhaHdGzZs0JIlSzRr1qxcxVKU2y4VzW0uSd26dVNAQICaNWumlStX5igWR7HHes1KUlKSLBZLlrdXFDb2Wmfp6el6+OGH9eyzzyoiIsI+wTuIPdZZenq6vvzyS1WpUkWRkZEKCAhQo0aNtHz5cru1I7/Yax9r0qSJVq5cqT/++EPGGG3cuFG//vqr2rdvb5+GIF/lZr+51j///KNLly6pZMmSNuWbNm1SQECAqlatqscff1xnzpzJ09hz41bba4zR+vXrdfDgQbVo0UJS9o4LHMkebc5QELexlPs2v/jiiwoICNCgQYMyTSvo2zkrBSLh/uuvv5SWlqYyZcrYlJcpU0bx8fFZfiY+Pv6G9TP+vVmdgIAAm+kuLi4qWbJkpuU2adJEHh4eqly5spo3b64XX3wx27EU1XZXrVpVH3zwgVasWKGPPvpI6enpatKkiU6cOFFo233mzBkNGDBAMTEx8vHxyVUsN1LY214Ut7mXl5def/11LVmyRF9++aWaNWumHj162CTdt7LN7cke6/VaFy9e1KhRo9SnT5/r7heFib3W2bRp0+Ti4qInn3wy74N2MHuss9OnT+v8+fOaOnWqOnTooK+//lr33HOP7r33Xm3evNk+Dckn9trHZs6cqfDwcJUtW1Zubm7q0KGDZs2alenAG4VTbvaba40aNUrBwcE2iUiHDh20YMECrV+/XtOmTdPmzZvVsWNHpaWl5Wn8OZXb9iYlJcnLy0tubm7q3LmzZs6cqbvvvltS9o4LHMkebZYK7jaWctfmb775Ru+//77mzZuX5fSCvp2z4uLoAAqLxYsX69y5c/rxxx/17LPP6rXXXtNzzz3n6LDs7kbtbty4sRo3bmyt26RJE1WvXl1z5szRpEmTHBXyLRk8eLAefPDB2/IAJjttL4rbvHTp0ho5cqR1vEGDBjp58qReffVVdevWzYGROd6lS5fUq1cvGWM0e/ZsR4dTYO3atUszZszQ7t27ZbFYHB1OoZCeni5J6t69u0aMGCFJqlOnjr777ju9++67ma6mwpWEe/v27Vq5cqVCQ0O1ZcsWRUVFZUqwcHuaOnWqFi1apE2bNtk8zLR3797Wv2vWrKlatWqpYsWK2rRpk9q2beuIUG+Jt7e3YmNjdf78ea1fv14jR45UhQoV1KpVK0eHZjc3a3NR2sbnzp3Tww8/rHnz5ql06dKODifPFIgz3KVLl5azs7MSEhJsyhMSEhQYGJjlZwIDA29YP+Pfm9U5ffq0zfTLly/r77//zrTckJAQhYeHq0+fPpo6daomTJhg/eXoZrEU1XZfy9XVVXXr1tXhw4dv1OwC3e4NGzbotddek4uLi1xcXDRo0CAlJSXJxcVFH3zwQbZiKcptv1ZR2OZZadSokU2bbmWb25M91muGjGT7999/19q1a4vE2W3JPuts69atOn36tMqVK2f9/vz+++96+umnFRYWZpd25Cd7rLPSpUvLxcVF4eHhNnWqV69e6J9Sbo/19e+//+q///2v3njjDXXt2lW1atXS0KFD9cADD+i1116zT0OQr3Kz32R47bXXNHXqVH399deqVavWDetWqFBBpUuXvun/2/aW2/Y6OTmpUqVKqlOnjp5++mndd999mjJliqTsHRc4kj3anJWCso2lnLf5yJEjOnr0qLp27Wr9/3TBggVauXKlXFxcdOTIkQK/nbNSIBJuNzc31atXT+vXr7eWpaena/369TZn067WuHFjm/qStHbtWmv98uXLKzAw0KZOcnKyvv/+e2udxo0bKzExUbt27bLW2bBhg9LT09WoUaPrxpuenq5Lly5Zf6G/WSxFtd3XSktL0969exUUFFRo271t2zbFxsZahxdffNH6y+I999yTrViKctuvVRS2eVZiY2Nt2nQr29ye7LFepf9Ltg8dOqR169apVKlS9mmAA9hjnT388MP66aefbL4/wcHBevbZZ7VmzRr7NSaf2GOdubm5qUGDBjp48KBNnV9//VWhoaF53IL8ZY/1denSJV26dElOTraHbc7Oztf9PxmFS272G0l65ZVXNGnSJK1evdrmeSXXc+LECZ05c+am/2/bW27be6309HSlpKRIyt5xgSPZo81ZKSjbWMp5m6tVq6a9e/fa/H/arVs3tW7dWrGxsQoJCSnw2zlLjn1m2/9ZtGiRcXd3NzExMWb//v1myJAhxs/Pz/rKoYcfftiMHj3aWv/bb781Li4u5rXXXjMHDhww48ePz/KVQX5+fmbFihXmp59+Mt27d8/ylUF169Y133//vfnmm29M5cqVbV4Z9NFHH5nFixeb/fv3myNHjpjFixeb4OBg07dv3xzFUhTbPXHiRLNmzRpz5MgRs2vXLtO7d2/j4eFhfv7550Lb7mtl9VTuW9nehb3tRXGbx8TEmIULF5oDBw6YAwcOmJdeesk4OTmZDz74IEexOEper9fU1FTTrVs3U7ZsWRMbG2vzmpGUlBSHtDGv2WNfvFZRe0q5PdbZ0qVLjaurq5k7d645dOiQmTlzpnF2djZbt27N9/blNXusr5YtW5qIiAizceNG89tvv5no6Gjj4eFh3nnnnXxvH+wjp/vN1KlTjZubm/nss89s+upz584ZY4w5d+6ceeaZZ8y2bdtMXFycWbdunbnzzjtN5cqVzcWLFx3SxqvltL0vv/yy+frrr82RI0fM/v37zWuvvWZcXFzMvHnzrHWyc1zgSHnd5oK+jY3JeZuvldVT2Av6dr5WgUm4jTFm5syZply5csbNzc00bNjQbN++3TqtZcuWpn///jb1P/30U1OlShXj5uZmIiIizJdffmkzPT093YwbN86UKVPGuLu7m7Zt25qDBw/a1Dlz5ozp06eP8fLyMj4+PmbgwIHWjsqYKzvJnXfeaby8vEzx4sVNeHi4efnllzNt0JvFUhTbPXz4cGvcZcqUMZ06dTK7d+8u1O2+1vVeg3Ur27swt70obvOYmBhTvXp1U6xYMePj42MaNmxolixZkin2W93m9pSX6zXjNWlZDRs3bsynFtlfXu+L1ypqCbcx9lln77//vqlUqZLx8PAwtWvXNsuXL7d3M/JNXq+vU6dOmQEDBpjg4GDj4eFhqlatal5//XWTnp6eH81BPsnJfhMaGpplXz1+/HhjjDH//POPad++vfH39zeurq4mNDTUDB482JroFAQ5ae/zzz9v7S9KlChhGjdubBYtWmQzv+wcFzhaXra5MGxjY3LeH14tq4S7MGznq1mMMcZBJ9cBAAAAACiyCsQ93AAAAAAAFDUk3AAAAAAA2AEJNwAAAAAAdkDCDQAAAACAHZBwAwAAAABgByTcAAAAAADYAQk3AAAAAAB2QMKNAiEsLEzTp0/Pdv1NmzbJYrEoMTHRbjEBAAAg/7Vq1UrDhw+3jmfnONFisWj58uW3vOy8mg+QgYQbOWKxWG44TJgwIVfz3bFjh4YMGZLt+k2aNNGpU6fk6+ubq+VlF4k9gMJgwIAB6tGjh6PDAHCb69q1qzp06JDltK1bt8piseinn37K8XxzepyYHRMmTFCdOnUylZ86dUodO3bM02VdKyYmRn5+fnZdBgoOF0cHgMLl1KlT1r8XL16sF154QQcPHrSWeXl5Wf82xigtLU0uLjffzfz9/XMUh5ubmwIDA3P0GQAAANjPoEGD1LNnT504cUJly5a1mRYdHa369eurVq1aOZ5vTo8TbwXHl8hrnOFGjgQGBloHX19fWSwW6/gvv/wib29vrVq1SvXq1ZO7u7u++eYbHTlyRN27d1eZMmXk5eWlBg0aaN26dTbzvfZSIYvFovfee0/33HOPihUrpsqVK2vlypXW6deeec74pXDNmjWqXr26vLy81KFDB5sfCC5fvqwnn3xSfn5+KlWqlEaNGqX+/fvf0lmhs2fPql+/fipRooSKFSumjh076tChQ9bpv//+u7p27aoSJUqoePHiioiI0FdffWX9bN++feXv7y9PT09VrlxZ0dHRuY4FALKyefNmNWzYUO7u7goKCtLo0aN1+fJl6/TPPvtMNWvWlKenp0qVKqV27drpwoULkq70tQ0bNlTx4sXl5+enpk2b6vfff3dUUwAUcF26dJG/v79iYmJsys+fP68lS5Zo0KBBOnPmjPr06aM77rhDxYoVU82aNfXJJ5/ccL7XHiceOnRILVq0kIeHh8LDw7V27dpMnxk1apSqVKmiYsWKqUKFCho3bpwuXbok6cpx48SJE/Xjjz9ar9LMiPnaS8r37t2rNm3aWPvIIUOG6Pz589bpGVcYvfbaawoKClKpUqUUFRVlXVZuHDt2TN27d5eXl5d8fHzUq1cvJSQkWKf/+OOPat26tby9veXj46N69epp586dkm587AnHIOFGnhs9erSmTp2qAwcOqFatWjp//rw6deqk9evXa8+ePerQoYO6du2qY8eO3XA+EydOVK9evfTTTz+pU6dO6tu3r/7+++/r1v/nn3/02muv6cMPP9SWLVt07NgxPfPMM9bp06ZN08cff6zo6Gh9++23Sk5OvuV7dAYMGKCdO3dq5cqV2rZtm4wx6tSpk7WTjYqKUkpKirZs2aK9e/dq2rRp1qsAxo0bp/3792vVqlU6cOCAZs+erdKlS99SPABwtT/++EOdOnVSgwYN9OOPP2r27Nl6//33NXnyZElXrlrq06ePHnnkER04cECbNm3SvffeK2OMLl++rB49eqhly5b66aeftG3bNg0ZMkQWi8XBrQJQULm4uKhfv36KiYmRMcZavmTJEqWlpalPnz66ePGi6tWrpy+//FL79u3TkCFD9PDDD+uHH37I1jLS09N17733ys3NTd9//73effddjRo1KlM9b29vxcTEaP/+/ZoxY4bmzZunN998U5L0wAMP6Omnn1ZERIROnTqlU6dO6YEHHsg0jwsXLigyMlIlSpTQjh07tGTJEq1bt05Dhw61qbdx40YdOXJEGzdu1Pz58xUTE5PpR4fsSk9PV/fu3fX3339r8+bNWrt2rX777Teb+Pr27auyZctqx44d2rVrl0aPHi1XV1dJNz72hIMYIJeio6ONr6+vdXzjxo1Gklm+fPlNPxsREWFmzpxpHQ8NDTVvvvmmdVySGTt2rHX8/PnzRpJZtWqVzbLOnj1rjUWSOXz4sPUzs2bNMmXKlLGOlylTxrz66qvW8cuXL5ty5cqZ7t27XzfOa5dztV9//dVIMt9++6217K+//jKenp7m008/NcYYU7NmTTNhwoQs5921a1czcODA6y4bALKrf//+WfZl//3vf03VqlVNenq6tWzWrFnGy8vLpKWlmV27dhlJ5ujRo5k+e+bMGSPJbNq0yZ6hAyhiDhw4YCSZjRs3WsuaN29uHnrooet+pnPnzubpp5+2jrds2dI89dRT1vGrjxPXrFljXFxczB9//GGdvmrVKiPJLFu27LrLePXVV029evWs4+PHjze1a9fOVO/q+cydO9eUKFHCnD9/3jr9yy+/NE5OTiY+Pt4Yc6X/DQ0NNZcvX7bWuf/++80DDzxw3ViuPYa+2tdff22cnZ3NsWPHrGU///yzkWR++OEHY4wx3t7eJiYmJsvP3+jYE47BGW7kufr169uMnz9/Xs8884yqV68uPz8/eXl56cCBAzc9w331PT7FixeXj4+PTp8+fd36xYoVU8WKFa3jQUFB1vpJSUlKSEhQw4YNrdOdnZ1Vr169HLXtagcOHJCLi4saNWpkLStVqpSqVq2qAwcOSJKefPJJTZ48WU2bNtX48eNtHhTy+OOPa9GiRapTp46ee+45fffdd7mOBQCycuDAATVu3NjmrHTTpk11/vx5nThxQrVr11bbtm1Vs2ZN3X///Zo3b57Onj0rSSpZsqQGDBigyMhIde3aVTNmzLC5TQcAslKtWjU1adJEH3zwgSTp8OHD2rp1qwYNGiRJSktL06RJk1SzZk2VLFlSXl5eWrNmzU2PCzMcOHBAISEhCg4OtpY1btw4U73FixeradOmCgwMlJeXl8aOHZvtZVy9rNq1a6t48eLWsqZNmyo9Pd3mGUYRERFydna2jl99DJpTGe0LCQmxloWHh8vPz896fDly5Eg9+uijateunaZOnaojR45Y697o2BOOQcKNPHd1pyRJzzzzjJYtW6aXX35ZW7duVWxsrGrWrKnU1NQbzifj0pgMFotF6enpOapvrrqcyREeffRR/fbbb3r44Ye1d+9e1a9fXzNnzpQkdezYUb///rtGjBihkydPqm3btjaXwAOAvTk7O2vt2rVatWqVwsPDNXPmTFWtWlVxcXGSrjzkaNu2bWrSpIkWL16sKlWqaPv27Q6OGkBBN2jQIH3++ec6d+6coqOjVbFiRbVs2VKS9Oqrr2rGjBkaNWqUNm7cqNjYWEVGRt70uDAntm3bpr59+6pTp0764osvtGfPHj3//PN5uoyr5fSY9VZNmDBBP//8szp37qwNGzYoPDxcy5Ytk3TjY084Bgk37O7bb7/VgAEDdM8996hmzZoKDAzU0aNH8zUGX19flSlTRjt27LCWpaWlaffu3bmeZ/Xq1XX58mV9//331rIzZ87o4MGDCg8Pt5aFhIToP//5j5YuXaqnn35a8+bNs07z9/dX//799dFHH2n69OmaO3duruMBgGtVr17d+nyJDN9++628vb2tTxC2WCxq2rSpJk6cqD179sjNzc164CZJdevW1ZgxY/Tdd9+pRo0aWrhwYb63A0Dh0qtXLzk5OWnhwoVasGCBHnnkEeuVNt9++626d++uhx56SLVr11aFChX066+/Znve1atX1/Hjx22uuLn2h8DvvvtOoaGhev7551W/fn1Vrlw50wMf3dzclJaWdtNl/fjjj9YHSWbE7+TkpKpVq2Y75pzIaN/x48etZfv371diYqLN8WWVKlU0YsQIff3117r33nttHrx7o2NP5D9eCwa7q1y5spYuXaquXbvKYrFo3Lhxdv3V73qGDRumKVOmqFKlSqpWrZpmzpyps2fPZusBQHv37pW3t7d13GKxqHbt2urevbsGDx6sOXPmyNvbW6NHj9Ydd9yh7t27S5KGDx+ujh07qkqVKjp79qw2btyo6tWrS5JeeOEF1atXTxEREUpJSdEXX3xhnQYAOZWUlKTY2FibsiFDhmj69OkaNmyYhg4dqoMHD2r8+PEaOXKknJyc9P3332v9+vVq3769AgIC9P333+vPP/9U9erVFRcXp7lz56pbt24KDg7WwYMHdejQIfXr188xDQRQaHh5eemBBx7QmDFjlJycrAEDBlinVa5cWZ999pm+++47lShRQm+88YYSEhJskskbadeunapUqaL+/fvr1VdfVXJysp5//nmbOpUrV9axY8e0aNEiNWjQQF9++aXND4nSlSefx8XFKTY2VmXLlpW3t7fc3d1t6vTt21fjx49X//79NWHCBP35558aNmyYHn74YZUpUyZ3K+f/S0tLy9Rnu7u7q127dqpZs6b69u2r6dOn6/Lly3riiSfUsmVL1a9fX//++6+effZZ3XfffSpfvrxOnDihHTt2qGfPnpJufOwJxyDhht298cYbeuSRR9SkSROVLl1ao0aNUnJycr7HMWrUKMXHx6tfv35ydnbWkCFDFBkZaXPPzfW0aNHCZtzZ2VmXL19WdHS0nnrqKXXp0kWpqalq0aKFvvrqK+ulRWlpaYqKitKJEyfk4+OjDh06WJ+Q6ebmpjFjxujo0aPy9PRU8+bNtWjRorxvOIDbwqZNm1S3bl2bskGDBumrr77Ss88+q9q1a6tkyZIaNGiQxo4dK0ny8fHRli1bNH36dCUnJys0NFSvv/66OnbsqISEBP3yyy+aP3++zpw5o6CgIEVFRemxxx5zRPMAFDKDBg3S+++/r06dOtncbz127Fj99ttvioyMVLFixTRkyBD16NFDSUlJ2Zqvk5OTli1bpkGDBqlhw4YKCwvTW2+9pQ4dOljrdOvWTSNGjNDQoUOVkpKizp07a9y4cZowYYK1Ts+ePbV06VK1bt1aiYmJio6OtvlhQLryfKA1a9boqaeeUoMGDVSsWDH17NlTb7zxxi2tG+nKM46u7bMrVqyow4cPa8WKFRo2bJhatGghJycndejQwXpZuLOzs86cOaN+/fopISFBpUuX1r333quJEydKuvGxJxzDYhx9kyvgIOnp6apevbp69eqlSZMmOTocAAAAAEUMZ7hx2/j999/19ddfq2XLlkpJSdHbb7+tuLg4Pfjgg44ODQAAAEARxEPTcNtwcnJSTEyMGjRooKZNm2rv3r1at24d97UAAAAAsAsuKQcAAAAAwA44ww0AAAAAgB2QcAMAAAAAYAck3AAAAAAA2AEJNwAAAAAAdkDCDQAAAACAHZBwAwAAAABgByTcAAAAAADYAQk3AAAAAAB2QMINAAAAAIAd/D8unb7cs8eq1wAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(1,3, figsize=(12,4))\n", + "\n", + "ax[0].hist([all_spec_train_loss_dense, all_unif_train_loss_dense], bins=bins)\n", + "ax[0].set_xlabel(\"Training Loss\")\n", + "ax[0].set_ylabel(\"Count\")\n", + "\n", + "ax[1].hist([all_spec_loss_dense, all_unif_loss_dense], bins=100)\n", + "ax[1].set_xlabel(\"Loss\")\n", + "\n", + "ax[2].hist([all_spec_validate_loss_dense, all_unif_validate_loss_dense], bins=100, label=[\"Spectral Init\", \"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", + "fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "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": 103, + "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": 125, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\iijof\\AppData\\Local\\Temp\\ipykernel_41056\\814593225.py:17: 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\"], all_unif_fitNoteParams[0][\"internalNoteIntercept\"]], bins=100)\n", + "ax[0][0].set_xlabel(\"Fitted Note Intercepts\")\n", + "\n", + "ax[0][1].hist([all_spec_fitNoteParams[0][\"internalNoteFactor1\"], all_unif_fitNoteParams[0][\"internalNoteFactor1\"]], bins=100, label=[\"Spectral Init\", \"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\"], all_unif_fitRaterParams[0][\"internalRaterIntercept\"]], bins=100)\n", + "ax[1][0].set_xlabel(\"Fitted Rater Intercepts\")\n", + "\n", + "ax[1][1].hist([all_spec_fitRaterParams[0][\"internalRaterFactor1\"], all_unif_fitRaterParams[0][\"internalRaterFactor1\"]], bins=100)\n", + "ax[1][1].set_xlabel(\"Fitted Rater Factor1s\")\n", + "\n", + "fig.suptitle(\"Fitted Parameters for Spase Sample, 10k Ratings\")\n", + "fig.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\iijof\\AppData\\Local\\Temp\\ipykernel_41056\\3332211367.py:17: 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\"], all_unif_fitNoteParams_dense[0][\"internalNoteIntercept\"]], bins=100)\n", + "ax[0][0].set_xlabel(\"Fitted Note Intercepts\")\n", + "\n", + "ax[0][1].hist([all_spec_fitNoteParams_dense[0][\"internalNoteFactor1\"], all_unif_fitNoteParams_dense[0][\"internalNoteFactor1\"]], bins=100, label=[\"Spectral Init\", \"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_dense[0][\"internalRaterIntercept\"], all_unif_fitRaterParams_dense[0][\"internalRaterIntercept\"]], bins=100)\n", + "ax[1][0].set_xlabel(\"Fitted Rater Intercepts\")\n", + "\n", + "ax[1][1].hist([all_spec_fitRaterParams_dense[0][\"internalRaterFactor1\"], all_unif_fitRaterParams_dense[0][\"internalRaterFactor1\"]], bins=100)\n", + "ax[1][1].set_xlabel(\"Fitted Rater Factor1s\")\n", + "\n", + "fig.suptitle(\"Fitted Parameters for Dense Sample, 10k Users and 10k Notes\")\n", + "fig.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Additionally, in all settings, the spectral initialization always gives a global intercept near $0.6$, very close the the mean rating, which is what I set empty cells in the to-be-decomposed matrix to. The uniform initialization, on the other hand, almost always gives a global intercept near $0.08$. Since the global intercept is initialized to 0, I don't know where this comes from. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "rater_means = model_data.rating_labels[[\"noteIndex\", \"helpfulNum\"]].groupby(\"noteIndex\").agg(\"mean\")\n", + "note_means = model_data.rating_labels[[\"noteIndex\", \"helpfulNum\"]].groupby(\"noteIndex\").agg(\"mean\")\n", + "model_data_with_means = model_data.rating_labels.join(rater_means, on=\"raterIndex\", rsuffix=\"RaterMean\").join(note_means, on=\"noteIndex\", rsuffix=\"NoteMean\")\n", + "ols_coefs = np.linalg.lstsq(model_data_with_means[[\"helpfulNumRaterMean\", \"helpfulNumNoteMean\"]], model_data_with_means[\"helpfulNum\"])\n", + "ols_coefs" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "normalizedLossHyperparameters=NormalizedLossHyperparameters(\n", + " globalSignNorm=True, noteSignAlpha=None, noteNormExp=0, raterNormExp=-0.25\n", + " )" + ] + } + ], + "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 +} From cd6cc739aa891251b8884c4bdf39f3145f5351cc Mon Sep 17 00:00:00 2001 From: IanJoffe Date: Wed, 4 Sep 2024 18:53:47 -0500 Subject: [PATCH 4/7] iterative spectral init and full tests --- .../matrix_factorization.py | 72 +- sourcecode/test_mf.ipynb | 664 +++++++++++++++--- 2 files changed, 638 insertions(+), 98 deletions(-) diff --git a/sourcecode/scoring/matrix_factorization/matrix_factorization.py b/sourcecode/scoring/matrix_factorization/matrix_factorization.py index 45792deab..1180736c1 100644 --- a/sourcecode/scoring/matrix_factorization/matrix_factorization.py +++ b/sourcecode/scoring/matrix_factorization/matrix_factorization.py @@ -160,6 +160,26 @@ def get_note_and_rater_id_maps( return noteIdMap, raterIdMap, ratingFeaturesAndLabels + def _form_data_df(self): + """ + Returns: pd.DataFrame, a (number of notes) x (number of raters) df filled with ratings data, + with validation data nan'ed out. + + This takes up a lot of memeory - 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. + """ + 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 + return data_df + def _initialize_parameters( self, noteInit: Optional[pd.DataFrame] = None, @@ -498,6 +518,7 @@ def run_mf( userInit: pd.DataFrame = None, globalInterceptInit: Optional[float] = None, useSpectralInit: Optional[bool] = False, + additonalSpectralInitIters: Optional[int] = 0, specificNoteId: Optional[int] = None, validatePercent: Optional[float] = None, freezeRaterParameters: bool = False, @@ -514,6 +535,8 @@ 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 + additionalSpectralInitIters (int, optional): How many times to reinitialize and refit with SVD specificNoteId (int, optional) Do approximate analysis to score a particular note Returns: @@ -556,18 +579,15 @@ def run_mf( if useSpectralInit: self._create_train_validate_sets(validatePercent) - 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 # fix: get better weights than 1/2, 1/2 on next line - mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=0.0)[:,np.newaxis] + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=0.0) - np.nanmean(data_matrix) # warning can be ignored, I deal with it on the next line + data_df = self._form_data_df() + data_matrix = data_df.values + # might be worth trying to tune the weights from 1/2-1/2, I didn't see a huge different in limited experiments but don't have the compute to be definative + 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) # warning can be ignored, I deal with it by wrapping with a nan_to_num filled_matrix = np.where(np.isnan(data_matrix), mean_matrix, data_matrix) - U, S, Vt = svds(filled_matrix, k=1) + 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] @@ -582,10 +602,42 @@ def run_mf( c.internalRaterInterceptKey: np.zeros(len(user_factor_init_vals)) }) globalInterceptInit = np.nanmean(data_matrix) + del data_df, data_matrix # save lots of memory + # 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 index 6d4cdc767..b7b8dc0ad 100644 --- a/sourcecode/test_mf.ipynb +++ b/sourcecode/test_mf.ipynb @@ -11,12 +11,12 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "I noticed that previously, 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 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. " + "I noticed that previously, 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": 50, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -24,13 +24,12 @@ "import pandas as pd\n", "import matplotlib.pyplot as plt\n", "from scoring.matrix_factorization.matrix_factorization import MatrixFactorization\n", - "# from scoring.matrix_factorization.normalized_loss import NormalizedLossHyperparameters\n", "from scoring.process_data import preprocess_data" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -40,18 +39,225 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ - "preprocessed_ratings_df_sample = pd.read_csv(\"ratings-00009-preprocessed.tsv\", sep='\\t')" + "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, + "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n" + ] + } + ], "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", @@ -67,9 +273,56 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n" + ] + } + ], "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", @@ -85,9 +338,216 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n" + ] + } + ], "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", @@ -99,47 +559,118 @@ " 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, useSpectralInit=True, validatePercent=0.30)\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, useSpectralInit=False, validatePercent=0.30)\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, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", + " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", + "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", + " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n" + ] + } + ], "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", - " preprocessed_ratings_df_sample = preprocessed_ratings_df.sample(n=30000, replace=False)\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, useSpectralInit=True, validatePercent=0.30)\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, useSpectralInit=False, validatePercent=0.30)\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 surprsing! 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 the uniform initialization gave better training loss, but the spectal initialization gave far better validation 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!\n", + "\n", + "I **have not** tested the spectral initialization when using `NormalizedLoss`, or against a uniform initialization using `NormalizedLoss`.\n", + "\n", + "The uniform initialization also does much better in the metric just titled loss, which looks just the loss of Adam's last batch. I expect the other loss metrics to be more informative so I'm not too worried about it, but I figured I'd include it since the original code chose to return it so you might find it relevant for something. \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) pair) which I found intuative 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 was 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. They definitely are a little bit different, but neither looks more right or wrong than the other. This is also something interesting to continue to ponder. \n", + "\n", + "Unfortunately, SVD is expenseive to compute, and also 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 sure, but it's possible there exist algorithms to get the top of the SVD without ever actually forming the raters-by-notes matrix." + ] + }, { "cell_type": "code", - "execution_count": 94, + "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\iijof\\AppData\\Local\\Temp\\ipykernel_41056\\3455664907.py:20: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + "C:\\Users\\iijof\\AppData\\Local\\Temp\\ipykernel_19676\\1632991799.py:18: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", " fig.show()\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -149,8 +680,6 @@ } ], "source": [ - "# I accidently sorted all_unif_train_loss\n", - "\n", "fig, ax = plt.subplots(1,3, figsize=(12,4))\n", "\n", "x_min, x_max = 0.0003, 0.0005 # cut out one outlier to the right with the of all_train_loss_unif\n", @@ -173,20 +702,20 @@ }, { "cell_type": "code", - "execution_count": 98, + "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\iijof\\AppData\\Local\\Temp\\ipykernel_41056\\4160637875.py:15: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + "C:\\Users\\iijof\\AppData\\Local\\Temp\\ipykernel_19676\\3562222091.py:15: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", " fig.show()\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -198,7 +727,7 @@ "source": [ "fig, ax = plt.subplots(1,3, figsize=(12,4))\n", "\n", - "ax[0].hist([all_spec_train_loss_dense, all_unif_train_loss_dense], bins=bins)\n", + "ax[0].hist([all_spec_train_loss_dense, all_unif_train_loss_dense], bins=100)\n", "ax[0].set_xlabel(\"Training Loss\")\n", "ax[0].set_ylabel(\"Count\")\n", "\n", @@ -215,12 +744,12 @@ }, { "cell_type": "code", - "execution_count": 102, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -254,12 +783,12 @@ }, { "cell_type": "code", - "execution_count": 103, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -293,20 +822,20 @@ }, { "cell_type": "code", - "execution_count": 125, + "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\iijof\\AppData\\Local\\Temp\\ipykernel_41056\\814593225.py:17: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + "C:\\Users\\iijof\\AppData\\Local\\Temp\\ipykernel_19676\\1107904351.py:17: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", " fig.show()\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -331,26 +860,26 @@ "ax[1][1].hist([all_spec_fitRaterParams[0][\"internalRaterFactor1\"], all_unif_fitRaterParams[0][\"internalRaterFactor1\"]], bins=100)\n", "ax[1][1].set_xlabel(\"Fitted Rater Factor1s\")\n", "\n", - "fig.suptitle(\"Fitted Parameters for Spase Sample, 10k Ratings\")\n", + "fig.suptitle(\"Fitted Parameters for One Spase Sample, 10k Ratings\")\n", "fig.show()" ] }, { "cell_type": "code", - "execution_count": 124, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\iijof\\AppData\\Local\\Temp\\ipykernel_41056\\3332211367.py:17: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + "C:\\Users\\iijof\\AppData\\Local\\Temp\\ipykernel_19676\\1387034380.py:17: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", " fig.show()\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -375,7 +904,7 @@ "ax[1][1].hist([all_spec_fitRaterParams_dense[0][\"internalRaterFactor1\"], all_unif_fitRaterParams_dense[0][\"internalRaterFactor1\"]], bins=100)\n", "ax[1][1].set_xlabel(\"Fitted Rater Factor1s\")\n", "\n", - "fig.suptitle(\"Fitted Parameters for Dense Sample, 10k Users and 10k Notes\")\n", + "fig.suptitle(\"Fitted Parameters for One Dense Sample, 10k Users and 10k Notes\")\n", "fig.show()" ] }, @@ -383,59 +912,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Additionally, in all settings, the spectral initialization always gives a global intercept near $0.6$, very close the the mean rating, which is what I set empty cells in the to-be-decomposed matrix to. The uniform initialization, on the other hand, almost always gives a global intercept near $0.08$. Since the global intercept is initialized to 0, I don't know where this comes from. " - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "rater_means = model_data.rating_labels[[\"noteIndex\", \"helpfulNum\"]].groupby(\"noteIndex\").agg(\"mean\")\n", - "note_means = model_data.rating_labels[[\"noteIndex\", \"helpfulNum\"]].groupby(\"noteIndex\").agg(\"mean\")\n", - "model_data_with_means = model_data.rating_labels.join(rater_means, on=\"raterIndex\", rsuffix=\"RaterMean\").join(note_means, on=\"noteIndex\", rsuffix=\"NoteMean\")\n", - "ols_coefs = np.linalg.lstsq(model_data_with_means[[\"helpfulNumRaterMean\", \"helpfulNumNoteMean\"]], model_data_with_means[\"helpfulNum\"])\n", - "ols_coefs" + "Additionally, in all settings, the spectral initialization always gives a global intercept near $0.6$, very close the the mean rating, which is what I set empty cells in the to-be-decomposed matrix to. The uniform initialization, on the other hand, almost always gives a global intercept near $0.08$. Since that code initializes the global intercept to 0, I don't know where this comes from. " ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "normalizedLossHyperparameters=NormalizedLossHyperparameters(\n", - " globalSignNorm=True, noteSignAlpha=None, noteNormExp=0, raterNormExp=-0.25\n", - " )" + "## Iterative Spectral Initialization\n", + "\n", + "I also had the 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, as above, 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. 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. " ] } ], From beb8099d5d768e60569db6f3a00ce06d0bc03409 Mon Sep 17 00:00:00 2001 From: IanJoffe Date: Thu, 12 Sep 2024 20:25:47 -0700 Subject: [PATCH 5/7] small debug and rerun tests --- .../matrix_factorization.py | 4 +- sourcecode/test_mf.ipynb | 125 +++++++++++++----- 2 files changed, 92 insertions(+), 37 deletions(-) diff --git a/sourcecode/scoring/matrix_factorization/matrix_factorization.py b/sourcecode/scoring/matrix_factorization/matrix_factorization.py index 1180736c1..99285b5f4 100644 --- a/sourcecode/scoring/matrix_factorization/matrix_factorization.py +++ b/sourcecode/scoring/matrix_factorization/matrix_factorization.py @@ -208,7 +208,7 @@ def _initialize_parameters( # 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] = 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 anywhere so not sure it saves memory + 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) ) @@ -242,7 +242,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( + self.mf_model.global_intercept.data = torch.nn.parameter.Parameter( torch.ones(1, 1, dtype=torch.float32) * globalInterceptInit ) diff --git a/sourcecode/test_mf.ipynb b/sourcecode/test_mf.ipynb index b7b8dc0ad..2f91527e6 100644 --- a/sourcecode/test_mf.ipynb +++ b/sourcecode/test_mf.ipynb @@ -551,7 +551,7 @@ "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", + "for _ in range(50): # change back to 50 later\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", @@ -568,7 +568,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -657,20 +657,20 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\iijof\\AppData\\Local\\Temp\\ipykernel_19676\\1632991799.py:18: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + "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": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -682,17 +682,19 @@ "source": [ "fig, ax = plt.subplots(1,3, figsize=(12,4))\n", "\n", - "x_min, x_max = 0.0003, 0.0005 # cut out one outlier to the right with the of all_train_loss_unif\n", - "bins = np.linspace(x_min, x_max, 100)\n", - "ax[0].set_xlim(x_min, x_max)\n", - "ax[0].hist([all_spec_train_loss, all_unif_train_loss], bins=bins)\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, all_unif_loss], bins=100)\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, all_unif_validate_loss], bins=100, label=[\"Spectral Init\", \"Uniform Init\"])\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", @@ -702,20 +704,60 @@ }, { "cell_type": "code", - "execution_count": 14, + "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": 10, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\iijof\\AppData\\Local\\Temp\\ipykernel_19676\\3562222091.py:15: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + "C:\\Users\\iijof\\AppData\\Local\\Temp\\ipykernel_5220\\650318728.py:18: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", " fig.show()\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -727,14 +769,17 @@ "source": [ "fig, ax = plt.subplots(1,3, figsize=(12,4))\n", "\n", - "ax[0].hist([all_spec_train_loss_dense, all_unif_train_loss_dense], bins=100)\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", - "ax[1].hist([all_spec_loss_dense, all_unif_loss_dense], bins=100)\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", - "ax[2].hist([all_spec_validate_loss_dense, all_unif_validate_loss_dense], bins=100, label=[\"Spectral Init\", \"Uniform Init\"])\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", @@ -744,12 +789,12 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -783,12 +828,12 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -822,20 +867,20 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\iijof\\AppData\\Local\\Temp\\ipykernel_19676\\1107904351.py:17: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + "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": "iVBORw0KGgoAAAANSUhEUgAAA0cAAAJJCAYAAABhx0xHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACueklEQVR4nOzdfVxO9/8H8NfVzXVV6roS3ZIKQ5Gbxcht1CpibBnGJhbGtxiZm74zwszm3izMjLZhbuZmJiKR3ORmTW5iTUSMylglN6X6/P7w63y7VHR1X17Px+M8uM55n3Pen3NdnXO9r3PO58iEEAJERERERESvOK2qToCIiIiIiKg6YHFEREREREQEFkdEREREREQAWBwREREREREBYHFEREREREQEgMURERERERERABZHREREREREAFgcERERERERAWBxREREREREBIDFEVGFun79OmQyGUJCQqo0j5CQEMhkMly/fr1K8yDN5eTkYOrUqbC2toaWlhYGDBhQ1SkRFSKTyRAUFFTVaWgsKCgIMpkM//zzT1Wn8lL5uRJRxWJxRFQG+UVHUcP06dOLnGfv3r1Ffol49OgRgoKCEBkZWbFJv0D+wTd/MDAwgIODA2bMmIGMjIwqy6syFPe+VLV169Zh4cKFGDhwIH744QdMmjSpwtcphMBPP/2E7t27w9jYGAYGBnB0dMScOXPw8OHDCl9/cfLy8vDjjz+iY8eOMDExgZGREZo1a4bhw4fj5MmTVZZXeblw4QIGDhwIGxsb6OnpoUGDBnjzzTexYsWKqk6tWrhz5w6mT5+Onj17wsjICDKZ7IX7yxMnTqBr164wMDCAhYUFJkyYgMzMzHLL5/n9v46ODho0aIARI0bg77//LtUyq8NxgOhVp1PVCRDVBnPmzIGdnZ3auFatWsHGxgaPHz+Grq6uNH7v3r0IDg4u9EX80aNHmD17NgDAxcWlolN+oVWrVsHQ0BCZmZk4cOAA5s2bh0OHDuH48eO19pfL4t6Xqnbo0CE0aNAAS5curZT15ebmYujQodi6dSu6deuGoKAgGBgY4OjRo5g9eza2bduGgwcPwtzcvFLyKWjChAkIDg5G//79MWzYMOjo6CA+Ph779u1D48aN0alTp0rPqbycOHECPXv2RKNGjTB69GhYWFjg5s2bOHnyJJYvX47x48dXdYpVLj4+Hl999RVee+01ODo6Ijo6utjY2NhYuLq6wt7eHkuWLMGtW7ewaNEiXLlyBfv27SvXvPL3/0+ePMHJkycREhKCY8eO4eLFi9DT09NoWS86DsyYMaPYH92IqPywOCIqB71790b79u2LnKbpwbE6GDhwIOrXrw8AGDt2LLy9vbFjxw6cPHkSzs7OpV5uTk4O8vLyIJfLyyvVak0IgSdPnkBfX7/Uy0hNTYWxsXG55ZSXl4fs7OxiP5cLFizA1q1b8cknn2DhwoXS+DFjxmDQoEEYMGAARowYUe5fMF8mJSUFK1euxOjRo7FmzRq1acuWLcPdu3crNZ/yNm/ePKhUKpw5c6bQ+52amlo1SVUzTk5OuHfvHkxMTPDLL7/g3XffLTb2v//9L+rWrYvIyEgolUoAgK2tLUaPHo0DBw7A3d293PIquP8fNWoU6tevj6+++gq7d+/GoEGDym09Ojo60NHh1zaiisbL6ogq0PP3HI0YMQLBwcEAoHY5xvXr12FqagoAmD17tjS+4FmMP//8EwMHDoSJiQn09PTQvn177N69u9A64+Li0KtXL+jr66Nhw4b4/PPPkZeXV6Z29OrVCwCQmJiI7OxszJw5E05OTlCpVKhTpw66deuGw4cPF9n2RYsWYdmyZWjSpAkUCgUuXbpUqmUEBwejcePGMDAwgLu7O27evAkhBObOnYuGDRtCX18f/fv3x/379wvlv2/fPnTr1g116tSBkZERvLy8EBcXJ00v7n3Jl5eXh2XLlqFly5bQ09ODubk5PvroI/z7779q67G1tUXfvn2xf/9+tG/fHvr6+vj2228BAOHh4ejatSuMjY1haGiI5s2b47///W+x2zy/7YcPH0ZcXJyUU/7lNg8fPsTkyZNhbW0NhUKB5s2bY9GiRRBCqC1HJpPB398fGzduRMuWLaFQKBAWFlbkOh8/foyFCxeiWbNmmD9/fqHp/fr1g4+PD8LCwtQuY8tv97Fjx/DGG29AT08PjRs3xo8//lhoGWlpaZg4caKUd9OmTfHVV1+99DOamJgIIQS6dOlSaJpMJoOZmZn0Ov9yp6ioKHz00UeoV68elEolhg8fXug9+/XXX+Hl5QUrKysoFAo0adIEc+fORW5urlrclStX4O3tDQsLC+jp6aFhw4YYMmQI0tPT1eI2bNgAJycn6Ovrw8TEBEOGDMHNmzdf2DYAuHr1Klq2bFlkIVywbQCwfv169OrVC2ZmZlAoFHBwcMCqVasKzZf/vkRGRkqfR0dHR+kztGPHDjg6OkJPTw9OTk44e/as2vwjRoyAoaEhrl27Bg8PD9SpUwdWVlaYM2dOoc9ZUf7++298+OGHMDc3h0KhQMuWLbFu3bqXzlccIyMjmJiYvDQuIyMD4eHheP/996XCCACGDx8OQ0NDbN269YXz37hxA02bNkWrVq2QkpKicZ7dunUD8Ow9zVeSfd7LjgNF3XOU//e9a9cutGrVStrORf2N538O9PT00KRJE3z77bdFLlPTfRVRbcOfIIjKQXp6eqEbevPPvBT00Ucf4fbt2wgPD8dPP/0kjTc1NcWqVaswbtw4vP3223jnnXcAAK1btwbwrODp0qULGjRogOnTp6NOnTrYunUrBgwYgO3bt+Ptt98GACQnJ6Nnz57IycmR4tasWVOmMxfA/w7y9erVQ0ZGBtauXYv33nsPo0ePxoMHD/D999/Dw8MDp0+fRtu2bdXmXb9+PZ48eYIxY8ZAoVDAxMRE42Vs3LgR2dnZGD9+PO7fv48FCxZg0KBB6NWrFyIjIzFt2jQkJCRgxYoV+OSTT9S+gP3000/w8fGBh4cHvvrqKzx69AirVq1C165dcfbsWdja2hb7vhR830JCQjBy5EhMmDABiYmJ+Oabb3D27FkcP35c7bLJ+Ph4vPfee/joo48wevRoNG/eHHFxcejbty9at26NOXPmQKFQICEhAcePHy92m5uamuKnn37CvHnzkJmZKRUr9vb2EELgrbfewuHDh+Hr64u2bdti//79mDJlCv7+++9Cl+AdOnQIW7duhb+/P+rXrw9bW9si13ns2DH8+++/+Pjjj4v9hXr48OFYv3499uzZo3YZW0JCAgYOHAhfX1/4+Phg3bp1GDFiBJycnNCyZUsAzy4Z6tGjB/7++2989NFHaNSoEU6cOIHAwEDcuXMHy5YtK3Z72NjYAAC2bduGd999FwYGBsXG5vP394exsTGCgoIQHx+PVatW4caNG4iMjJS+EIaEhMDQ0BABAQEwNDTEoUOHMHPmTGRkZEhnzrKzs+Hh4YGsrCyMHz8eFhYW+Pvvv7Fnzx6kpaVBpVIBeHb257PPPsOgQYMwatQo3L17FytWrED37t1x9uzZF54BtLGxQXR0NC5evIhWrVq9sF2rVq1Cy5Yt8dZbb0FHRwe//fYb/vOf/yAvLw9+fn5qsQkJCRg6dCg++ugjvP/++1i0aBH69euH1atX47///S/+85//AADmz5+PQYMGIT4+Hlpa//vdNDc3F56enujUqRMWLFiAsLAwzJo1Czk5OZgzZ06xOaakpKBTp07Sl3dTU1Ps27cPvr6+yMjIwMSJE1/YxrK4cOECcnJyCp3Nl8vlaNu2baEisKCrV6+iV69eMDExQXh4eJH78ZfJ7/imbt260riS7PNedhwozrFjx7Bjxw785z//gZGREb7++mt4e3sjKSkJ9erVAwCcPXsWnp6esLS0xOzZs5Gbm4s5c+ZIxVi+0uyriGodQUSltn79egGgyEEIIRITEwUAsX79emkePz8/UdSf3t27dwUAMWvWrELTXF1dhaOjo3jy5Ik0Li8vT3Tu3Fm89tpr0riJEycKAOLUqVPSuNTUVKFSqQQAkZiY+ML2zJo1SwAQ8fHx4u7duyIxMVF8++23QqFQCHNzc/Hw4UORk5MjsrKy1Ob7999/hbm5ufjwww+lcfltVyqVIjU1VS1e02WYmpqKtLQ0aXxgYKAAINq0aSOePn0qjX/vvfeEXC6XttODBw+EsbGxGD16tNq6kpOThUqlUhtf3Pty9OhRAUBs3LhRbXxYWFih8TY2NgKACAsLU4tdunSpACDu3r1baPkv06NHD9GyZUu1cbt27RIAxOeff642fuDAgUImk4mEhARpHAChpaUl4uLiXrquZcuWCQBi586dxcbcv39fABDvvPOONC6/3VFRUdK41NRUoVAoxOTJk6Vxc+fOFXXq1BF//fWX2jKnT58utLW1RVJS0gvzGz58uAAg6tatK95++22xaNEicfny5UJx+X+XTk5OIjs7Wxq/YMECAUD8+uuv0rhHjx4Vmv+jjz4SBgYG0ufo7NmzAoDYtm1bsbldv35daGtri3nz5qmNv3DhgtDR0Sk0/nkHDhwQ2traQltbWzg7O4upU6eK/fv3q+X/opw9PDxE48aN1cblvy8nTpyQxu3fv18AEPr6+uLGjRvS+G+//VYAEIcPH5bG+fj4CABi/Pjx0ri8vDzh5eUl5HK52uf5+X2Xr6+vsLS0FP/8849aTkOGDBEqlarINmhi27ZthfJ9flrBz2O+d999V1hYWEiv8/d5d+/eFZcvXxZWVlaiQ4cO4v79+y/NIf9zdvDgQXH37l1x8+ZN8csvvwhTU1OhUCjEzZs3pdiS7vNedBzIz7UgAEIul6v9zZ87d04AECtWrJDG9evXTxgYGIi///5bGnflyhWho6Ojtsyy7KuIagteVkdUDoKDgxEeHq42lJf79+/j0KFDGDRoEB48eIB//vkH//zzD+7duwcPDw9cuXJF6hlp79696NSpE9544w1pflNTUwwbNkyjdTZv3hympqaws7PDRx99hKZNmyI0NBQGBgbQ1taW7hnKy8vD/fv3pV9p//jjj0LL8vb2LvTrpKbLePfdd6Vf5wGgY8eOAID3339f7QxHx44dkZ2dLW2P8PBwpKWl4b333pO22z///ANtbW107Nix0GV8Rdm2bRtUKhXefPNNtWU4OTnB0NCw0DLs7Ozg4eGhNi7/jMGvv/5a5kscgWfvs7a2NiZMmKA2fvLkyRBCFLofqEePHnBwcHjpch88eADg2eVLxcmf9nzvhQ4ODtLlRMCzz13z5s1x7do1ady2bdvQrVs31K1bV21burm5ITc3F1FRUS/Mb/369fjmm29gZ2eHnTt34pNPPoG9vT1cXV2L7B1szJgxamf1xo0bBx0dHezdu1caV/Csav7fV7du3fDo0SP8+eefACB99vbv349Hjx4VmduOHTuQl5eHQYMGqbXNwsICr7322ks/a2+++Saio6Px1ltv4dy5c1iwYAE8PDzQoEGDQpfPFsw5/6x1jx49cO3atUKX+Tk4OKjdJ5j/t9OrVy80atSo0PiC71c+f39/6f/5Z4Kys7Nx8ODBItsihMD27dvRr18/CCHUtoeHhwfS09OL/DsvL48fPwYAKBSKQtP09PSk6QVdvHgRPXr0gK2tLQ4ePKh21udl3NzcYGpqCmtrawwcOBB16tTB7t270bBhQylG032eJtzc3NCkSRPpdevWraFUKqX3Mjc3FwcPHsSAAQNgZWUlxTVt2hS9e/dWW1Z576uIaiJeVkdUDt54441iO2Qoq4SEBAgh8Nlnn+Gzzz4rMiY1NRUNGjTAjRs3pC85BTVv3lyjdW7fvh1KpRK6urpo2LCh2oEXAH744QcsXrwYf/75J54+fSqNf77HvuLGabqMgl/igP99WbW2ti5yfP59JVeuXAHwv3umnlfwfoTiXLlyBenp6YXu+8j3/M3yReU/ePBgrF27FqNGjcL06dPh6uqKd955BwMHDlS7hKmkbty4ASsrq0JFjL29vTT9ZTkVJX95+UVSUYoroJ5/j4BnlxUVvMfnypUrOH/+fKFiOd/LOh7Q0tKCn58f/Pz8cO/ePRw/fhyrV6/Gvn37MGTIEBw9elQt/rXXXlN7bWhoCEtLS7XnfcXFxWHGjBk4dOhQoYIvv9Cws7NDQEAAlixZgo0bN6Jbt25466238P7770ufuStXrkAIUWid+QoWacXp0KEDduzYgezsbJw7dw47d+7E0qVLMXDgQMTGxkoF7vHjxzFr1ixER0cXKtbS09PVfkgo7d9OPi0tLTRu3FhtXLNmzQCg2Oem3b17F2lpaVizZk2hzjPyVWQnE/nFY1ZWVqFpxXWQ0q9fP5ibm2P//v0wNDTUaH3BwcFo1qwZ0tPTsW7dOkRFRRVZmGmyz9PEy/72UlNT8fjxYzRt2rRQ3PPjyntfRVQTsTgiqubyf7375JNPCp2RyFfUQa8sunfvXuy19hs2bMCIESMwYMAATJkyBWZmZtDW1sb8+fPVbkDOV9QXEU2Xoa2tXWQuxY0X/3+zeP62++mnn2BhYVEoriQ9P+Xl5cHMzAwbN24scvrzX/SLaq++vj6ioqJw+PBhhIaGIiwsDFu2bEGvXr1w4MCBYttRXkp6z1l+cXX+/PliHzZ7/vx5ACh0Jupl7wXwbFu++eabmDp1apGx+V+6S6JevXp466238NZbb8HFxQVHjhzBjRs3pHuTSiItLQ09evSAUqnEnDlz0KRJE+jp6eGPP/7AtGnT1H45X7x4MUaMGIFff/0VBw4cwIQJEzB//nycPHkSDRs2RF5eHmQyGfbt21fkttDkC7dcLkeHDh3QoUMHNGvWDCNHjsS2bdswa9YsXL16Fa6urmjRogWWLFkCa2tryOVy7N27F0uXLi30a39p/3bKIj+H999/Hz4+PkXGvOw+mrKwtLQE8Oy5SM+7c+eO2tmTfN7e3vjhhx+wceNGfPTRRxqtr+CPYwMGDEDXrl0xdOhQxMfHS++7pvs8TZTne1nV+yqi6oDFEVElK+45QcWNz//VVldXF25ubi9cto2NjXS2pKD4+HgNsyzeL7/8gsaNG2PHjh1qOc+aNatSl1ES+We8zMzMXrrtitv+TZo0wcGDB9GlS5cydWyhpaUFV1dXuLq6YsmSJfjiiy/w6aef4vDhwy/N7Xk2NjY4ePAgHjx4oHYGJ/8yME0KhILye6jatGkTPv300yK/COX3QNe3b1+Nl9+kSRNkZmZq3N6Xad++PY4cOYI7d+6otf3KlSvo2bOn9DozMxN37txBnz59ADzrvevevXvYsWMHunfvLsUlJiYWuR5HR0c4OjpixowZOHHiBLp06YLVq1fj888/R5MmTSCEgJ2dnUZFXknaBvzvi/5vv/2GrKws7N69W+2MQUkuES2NvLw8XLt2Ta1Nf/31FwAU27GHqakpjIyMkJubW+7vdUm0atUKOjo6+P3339W60s7OzkZsbGyR3WsvXLgQOjo6UqcGQ4cOLdW68wuenj174ptvvpGeS1TSfV5FPEfOzMwMenp6SEhIKDStqHHlua8iqol4jpSoktWpUwfAs1+tC8rvfev58WZmZnBxccG3335b5C+hBZ/v0qdPH5w8eRKnT59Wm17cWY/SyP/CXPBXyVOnTr3wgYwVsYyS8PDwgFKpxBdffKF2GUu+gtuuuPdl0KBByM3Nxdy5cwvNn5OTUyi+KEV1L57fI19Rl/68TJ8+fZCbm4tvvvlGbfzSpUshk8kK3UdQUgYGBvjkk08QHx+PTz/9tND00NBQhISEwMPDo1QPXB00aBCio6Oxf//+QtPS0tKQk5NT7LzJycm4dOlSofHZ2dmIiIiAlpZWoTOoa9asUXvfV61ahZycHGn7FPU5zM7OxsqVK9WWk5GRUSg3R0dHaGlpSe/fO++8A21tbcyePbvQL/ZCCNy7d6/YtgHPipuifunPvz8q/9LYonJOT0/H+vXrX7j8sij4ORNC4JtvvoGuri5cXV2LjNfW1oa3tze2b9+OixcvFppe0c+kUqlUcHNzw4YNG9QuEf3pp5+QmZlZ5PORZDIZ1qxZg4EDB8LHx6fIxySUlIuLC9544w0sW7YMT548AVDyfV5xx4Gy0NbWhpubG3bt2oXbt29L4xMSEgrdn1je+yqimohnjogqmZOTEwBgwoQJ8PDwgLa2NoYMGQJ9fX04ODhgy5YtaNasGUxMTNCqVSu0atUKwcHB6Nq1KxwdHTF69Gg0btwYKSkpiI6Oxq1bt3Du3DkAwNSpU/HTTz/B09MTH3/8sdSVt42NjXQ5VFn17dsXO3bswNtvvw0vLy8kJiZi9erVcHBwQGZmZqUtoySUSiVWrVqFDz74AK+//jqGDBkCU1NTJCUlITQ0FF26dJG++BX3vvTo0QMfffQR5s+fj9jYWLi7u0NXVxdXrlzBtm3bsHz5cgwcOPCFecyZMwdRUVHw8vKCjY0NUlNTsXLlSjRs2BBdu3bVuF39+vVDz5498emnn+L69eto06YNDhw4gF9//RUTJ04sdI+YJqZPn46zZ8/iq6++QnR0NLy9vaGvr49jx45hw4YNsLe3xw8//FCqZU+ZMgW7d+9G3759pW6+Hz58iAsXLuCXX37B9evXi72c89atW3jjjTfQq1cvuLq6wsLCAqmpqfj5559x7tw5TJw4sdC82dnZcHV1lbqoXrlyJbp27Yq33noLANC5c2fUrVsXPj4+mDBhAmQyGX766adCRcqhQ4fg7++Pd999F82aNUNOTg5++uknqQgAnp0V+/zzzxEYGIjr169jwIABMDIyQmJiInbu3IkxY8bgk08+KXbbjB8/Ho8ePcLbb7+NFi1aIDs7GydOnMCWLVtga2uLkSNHAgDc3d0hl8vRr18/fPTRR8jMzMR3330HMzOzIn88KSs9PT2EhYXBx8cHHTt2xL59+xAaGor//ve/xd47BgBffvklDh8+jI4dO2L06NFwcHDA/fv38ccff+DgwYNqX8LzL4ssyWVgn3/+OQBIzyn76aefcOzYMQDAjBkzpLh58+ahc+fO6NGjB8aMGYNbt25h8eLFcHd3h6enZ5HL1tLSwoYNGzBgwAAMGjQIe/fuLfZ+xZeZMmUK3n33XYSEhGDs2LEl3ue96DhQFkFBQThw4AC6dOmCcePGST+utGrVCrGxsVJcee+riGqkSu0bj6iWye/K9cyZM0VOL6or75ycHDF+/HhhamoqZDKZWjeqJ06cEE5OTkIulxfqzvXq1ati+PDhwsLCQujq6ooGDRqIvn37il9++UVtnefPnxc9evQQenp6okGDBmLu3Lni+++/16gr7xd145qXlye++OILYWNjIxQKhWjXrp3Ys2eP8PHxETY2NoXavnDhwnJfxuHDh4vsWrm49+Pw4cPCw8NDqFQqoaenJ5o0aSJGjBghfv/9dynmRe+LEEKsWbNGODk5CX19fWFkZCQcHR3F1KlTxe3bt6UYGxsb4eXlVai9ERERon///sLKykrI5XJhZWUl3nvvvUJdWhelqK68hXjWTfmkSZOElZWV0NXVFa+99ppYuHChyMvLU4sDIPz8/F66noJyc3PF+vXrRZcuXYRSqRR6enqiZcuWYvbs2SIzM7NQfHHt7tGjh+jRo0ehvAMDA0XTpk2FXC4X9evXF507dxaLFi0qstvqfBkZGWL58uXCw8NDNGzYUOjq6gojIyPh7OwsvvvuO7V2538Ojhw5IsaMGSPq1q0rDA0NxbBhw8S9e/fUlnv8+HHRqVMnoa+vL6ysrKQutFGgm+hr166JDz/8UDRp0kTo6ekJExMT0bNnT3Hw4MFCeW7fvl107dpV1KlTR9SpU0e0aNFC+Pn5ifj4+BdtcrFv3z7x4YcfihYtWghDQ0Mhl8tF06ZNxfjx40VKSopa7O7du0Xr1q2Fnp6esLW1FV999ZVYt25dob/x4t6Xoj4TRf2t+fj4iDp16oirV68Kd3d3YWBgIMzNzcWsWbNEbm5uoWU+3/10SkqK8PPzE9bW1kJXV1dYWFgIV1dXsWbNGrU4Jycnte61XwTFPDqhqK8zR48eFZ07dxZ6enrC1NRU+Pn5iYyMDLWYovZ5jx49Ej169BCGhobi5MmTxebyov1/bm6uaNKkiWjSpInIyckp8T5PiOKPA8V15V3U37eNjY3w8fFRGxcRESHatWsn5HK5aNKkiVi7dq2YPHmy0NPTU4sp7b6KqLaQCVEOd18SERFVE/kP7D1z5kyF9SL5KhgxYgR++eWXcj2b+7wHDx7AxMQEy5YtK/QAW6p4AwYMQFxcXJH3qhK9qnjPEREREVWJqKgoNGjQAKNHj67qVGq955/vdOXKFezduxcuLi5VkxBRNcV7joiIiKhKeHl5wcvLq6rTeCU0btwYI0aMQOPGjXHjxg2sWrUKcrm82K71iV5VLI6IiIiIajlPT0/8/PPPSE5OhkKhgLOzM7744otiH1xM9KriPUdERERERETgPUdEREREREQAWBwREREREREBYHFEREREREQEgMURERERERERABZHREREREREAFgcERERERERAWBxREREREREBIDFEREREREREQAWR0RERERERABYHBEREREREQFgcURERERERASAxREREREREREAFkdEREREREQAWBwREREREREBYHFEREREREQEgMURERERERERABZHREREREREAFgcERERERERAWBxREREREREBIDFEREREREREQAWR0RERERERABYHBEREREREQFgcURERERERASAxREREREREREAFkdEREREREQAWBwREREREREBYHFEREREREQEgMURERERERERABZHREREREREAFgcERERERERAWBxREREREREBIDFEREREREREQAWR0RERERERABYHBEREREREQFgcURERERERASAxREREREREREAFkdEREREREQAWBwREREREREBYHFEREREREQEgMURERERERERAEBHk+BVq1Zh1apVuH79OgCgZcuWmDlzJnr37g0AePLkCSZPnozNmzcjKysLHh4eWLlyJczNzaVlJCUlYdy4cTh8+DAMDQ3h4+OD+fPnQ0fnf6lERkYiICAAcXFxsLa2xowZMzBixAiNGpaXl4fbt2/DyMgIMplMo3mJiKj0hBB48OABrKysoKXF3+AK4rGJiKhqlPjYJDSwe/duERoaKv766y8RHx8v/vvf/wpdXV1x8eJFIYQQY8eOFdbW1iIiIkL8/vvvolOnTqJz587S/Dk5OaJVq1bCzc1NnD17Vuzdu1fUr19fBAYGSjHXrl0TBgYGIiAgQFy6dEmsWLFCaGtri7CwME1SFTdv3hQAOHDgwIFDFQ03b97UaL/9KuCxiQMHDhyqdnjZsUkmhBAoAxMTEyxcuBADBw6EqakpNm3ahIEDBwIA/vzzT9jb2yM6OhqdOnXCvn370LdvX9y+fVs6m7R69WpMmzYNd+/ehVwux7Rp0xAaGoqLFy9K6xgyZAjS0tIQFhZW4rzS09NhbGyMmzdvQqlUlqWJRESkgYyMDFhbWyMtLQ0qlaqq06lWeGwiIqoaJT02aXRZXUG5ubnYtm0bHj58CGdnZ8TExODp06dwc3OTYlq0aIFGjRpJxVF0dDQcHR3VLrPz8PDAuHHjEBcXh3bt2iE6OlptGfkxEydOfGE+WVlZyMrKkl4/ePAAAKBUKnkAIiKqArxsrLD8bcJjExFR1XjZsUnji8EvXLgAQ0NDKBQKjB07Fjt37oSDgwOSk5Mhl8thbGysFm9ubo7k5GQAQHJyslphlD89f9qLYjIyMvD48eNi85o/fz5UKpU0WFtba9o0IiIiIiJ6hWlcHDVv3hyxsbE4deoUxo0bBx8fH1y6dKkictNIYGAg0tPTpeHmzZtVnRIREREREdUgGl9WJ5fL0bRpUwCAk5MTzpw5g+XLl2Pw4MHIzs5GWlqa2tmjlJQUWFhYAAAsLCxw+vRpteWlpKRI0/L/zR9XMEapVEJfX7/YvBQKBRQKhabNISIiIiIiAlCGe47y5eXlISsrC05OTtDV1UVERAS8vb0BAPHx8UhKSoKzszMAwNnZGfPmzUNqairMzMwAAOHh4VAqlXBwcJBi9u7dq7aO8PBwaRlERERERAAghEBOTg5yc3OrOhWqYtra2tDR0Snz/a4aFUeBgYHo3bs3GjVqhAcPHmDTpk2IjIzE/v37oVKp4Ovri4CAAJiYmECpVGL8+PFwdnZGp06dAADu7u5wcHDABx98gAULFiA5ORkzZsyAn5+fdNZn7Nix+OabbzB16lR8+OGHOHToELZu3YrQ0NAyNZSIiIiIao/s7GzcuXMHjx49qupUqJowMDCApaUl5HJ5qZehUXGUmpqK4cOH486dO1CpVGjdujX279+PN998EwCwdOlSaGlpwdvbW+0hsPm0tbWxZ88ejBs3Ds7OzqhTpw58fHwwZ84cKcbOzg6hoaGYNGkSli9fjoYNG2Lt2rXw8PAodSOJiIiIqPbIy8tDYmIitLW1YWVlBblczh4yX2FCCGRnZ+Pu3btITEzEa6+9VuqHkJf5OUfVVUZGBlQqFdLT09ldKhFRJeL+t3jcNkTl48mTJ0hMTISNjQ0MDAyqOh2qJh49eoQbN27Azs4Oenp6atNKuv8tXUlFRGUXxIdjEhFRDRSkqjbHsNKeHaDaqTw+D/xEEVUB2+m8h46IiIioumFxREREREREpXL9+nXIZDLExsZW62WWVJm78iYiIiIiqg4q+8qM6196aRR/9+5dzJw5E6GhoUhJSUHdunXRpk0bzJw5E126dKmgLAuTyWTYuXMnBgwYUCnrc3FxQdu2bbFs2bISxVtbW+POnTuoX78+ACAyMhI9e/bEv//+q/Y81YrA4oiIiIiIqBJ4e3sjOzsbP/zwAxo3boyUlBRERETg3r17VZ1aIdnZ2WXqErsstLW1YWFhUSXr5mV1REREREQVLC0tDUePHsVXX32Fnj17wsbGBm+88QYCAwPx1ltvSXEymQyrVq1C7969oa+vj8aNG+OXX35RW9bNmzcxaNAgGBsbw8TEBP3798f169fVYtatW4eWLVtCoVDA0tIS/v7+AABbW1sAwNtvvw2ZTCa9DgoKQtu2bbF27Vq13t7CwsLQtWtXGBsbo169eujbty+uXr1apm1ha2uLL774Ah9++CGMjIzQqFEjrFmzRppe8LK669evo2fPngCAunXrQiaTYcSIEWVa/4uwOCIiIiIiqmCGhoYwNDTErl27kJWV9cLYzz77DN7e3jh37hyGDRuGIUOG4PLlywCAp0+fwsPDA0ZGRjh69CiOHz8OQ0NDeHp6Ijs7GwCwatUq+Pn5YcyYMbhw4QJ2796Npk2bAgDOnDkDAFi/fj3u3LkjvQaAhIQEbN++HTt27JDu93n48CECAgLw+++/IyIiAlpaWnj77beRl5dXpu2xePFitG/fHmfPnsV//vMfjBs3DvHx8YXirK2tsX37dgBAfHw87ty5g+XLl5dp3S/Cy+qIiIiIiCqYjo4OQkJCMHr0aKxevRqvv/46evTogSFDhqB169Zqse+++y5GjRoFAJg7dy7Cw8OxYsUKrFy5Elu2bEFeXh7Wrl0rPfh2/fr1MDY2RmRkJNzd3fH5559j8uTJ+Pjjj6VldujQAQBgamoKADA2Ni506Vp2djZ+/PFHKQZ4dilgQevWrYOpqSkuXbqEVq1alXp79OnTB//5z38AANOmTcPSpUtx+PBhNG/eXC1OW1sbJiYmAAAzM7MKv+eIZ46IiIiIiCqBt7c3bt++jd27d8PT0xORkZF4/fXXERISohbn7Oxc6HX+maNz584hISEBRkZG0tkoExMTPHnyBFevXkVqaipu374NV1dXjfOzsbFRK4wA4MqVK3jvvffQuHFjKJVK6TK8pKQkjZdfUMGCUCaTwcLCAqmpqWVaZnngmSMiIiIiokqip6eHN998E2+++SY+++wzjBo1CrNmzSrxfTSZmZlwcnLCxo0bC00zNTUt04NQ69SpU2hcv379YGNjg++++w5WVlbIy8tDq1atpEv4SktXV1fttUwmK/OleuWBZ46IiIiIiKqIg4MDHj58qDbu5MmThV7b29sDAF5//XVcuXIFZmZmaNq0qdqgUqlgZGQEW1tbREREFLtOXV1d5ObmvjS3e/fuIT4+HjNmzICrqyvs7e3x77//lqKVZZPfa15Jci4rFkdERERERBXs3r176NWrFzZs2IDz588jMTER27Ztw4IFC9C/f3+12G3btmHdunX466+/MGvWLJw+fVrqbW7YsGGoX78++vfvj6NHjyIxMRGRkZGYMGECbt26BeBZz3OLFy/G119/jStXruCPP/7AihUrpOXnF0/JyckvLHbq1q2LevXqYc2aNUhISMChQ4cQEBBQAVvnxWxsbCCTybBnzx7cvXsXmZmZFbYuFkdERERERBXM0NAQHTt2xNKlS9G9e3e0atUKn332GUaPHo1vvvlGLXb27NnYvHkzWrdujR9//BE///wzHBwcAAAGBgaIiopCo0aN8M4778De3h6+vr548uQJlEolAMDHxwfLli3DypUr0bJlS/Tt2xdXrlyRlr948WKEh4fD2toa7dq1KzZnLS0tbN68GTExMWjVqhUmTZqEhQsXVsDWebEGDRpg9uzZmD59OszNzaVCsSLIhBCiwpZehTIyMqBSqZCeni59UIiqC9vpobiuNxQISq/qVIjKHfe/xeO2oVohSPX//1bdMezJkydITExUex5PbSGTybBz504MGDCgqlOpcV70uSjp/pdnjoiIiIiIiMDiiIiIiIiICAC78iYiIiIiqjZq6R0vNQbPHBERUa3y5ZdfQiaTYeLEidK4J0+ewM/PD/Xq1YOhoSG8vb2RkpKiNl9SUhK8vLxgYGAAMzMzTJkyBTk5OWox+Q9sVCgUaNq0aaEHNxIRUc3G4oiIiGqNM2fO4Ntvv1V78joATJo0Cb/99hu2bduGI0eO4Pbt23jnnXek6bm5ufDy8kJ2djZOnDiBH374ASEhIZg5c6YUk5iYCC8vL/Ts2ROxsbGYOHEiRo0ahf3791da+4iIqGKxOCIiolohMzMTw4YNw3fffYe6detK49PT0/H9999jyZIl6NWrF5ycnLB+/XqcOHFCetDigQMHcOnSJWzYsAFt27ZF7969MXfuXAQHB0tPgV+9ejXs7OywePFi2Nvbw9/fHwMHDsTSpUurpL1ERFT+WBwREVGt4OfnBy8vL7i5uamNj4mJwdOnT9XGt2jRAo0aNUJ0dDQAIDo6Go6OjjA3N5diPDw8kJGRgbi4OCnm+WV7eHhIyyhKVlYWMjIy1AYiIqq+2CEDERHVeJs3b8Yff/yBM2fOFJqWnJwMuVwOY2NjtfHm5uZITk6WYgoWRvnT86e9KCYjIwOPHz+Gvr5+oXXPnz8fs2fPLnW7iIiocvHMERER1Wg3b97Exx9/jI0bN1a7h0EGBgYiPT1dGm7evFnVKRER0QtoVBzNnz8fHTp0gJGREczMzDBgwADEx8erxbi4uEAmk6kNY8eOVYthj0BERFReYmJikJqaitdffx06OjrQ0dHBkSNH8PXXX0NHRwfm5ubIzs5GWlqa2nwpKSmwsLAAAFhYWBTqvS7/9ctilEplkWeNAEChUECpVKoNRETlwdbWFsuWLZNeJycn480330SdOnUKnSmvKUJCQqo8d40uqzty5Aj8/PzQoUMH5OTk4L///S/c3d1x6dIl1KlTR4obPXo05syZI702MDCQ/p/fI5CFhQVOnDiBO3fuYPjw4dDV1cUXX3wB4H89Ao0dOxYbN25EREQERo0aBUtLS3h4eJS1zUREVIu4urriwoULauNGjhyJFi1aYNq0abC2toauri4iIiLg7e0NAIiPj0dSUhKcnZ0BAM7Ozpg3bx5SU1NhZmYGAAgPD4dSqYSDg4MUs3fvXrX1hIeHS8sgomogSFXJ60vXKNzFxQVt27ZVK2qAZ0XBxIkTC/2I8yJnzpxR+/69dOlS3LlzB7GxsVCpKnk7FEMmk2Hnzp0YMGBAieIHDx6MPn36SK+DgoKwa9cuxMbGVkyCRdCoOAoLC1N7HRISAjMzM8TExKB79+7SeAMDA+mXtufl9wh08OBBmJubo23btpg7dy6mTZuGoKAgyOVytR6BAMDe3h7Hjh3D0qVLWRwREZEaIyMjtGrVSm1cnTp1UK9ePWm8r68vAgICYGJiAqVSifHjx8PZ2RmdOnUCALi7u8PBwQEffPABFixYgOTkZMyYMQN+fn5QKBQAgLFjx+Kbb77B1KlT8eGHH+LQoUPYunUrQkNDK7fBREQATE1N1V5fvXoVTk5OeO2110q9zOzsbMjl8rKmVmr6+vrFnomvLGW65yg9/Vm1bGJiojZ+48aNqF+/Plq1aoXAwEA8evRImlZRPQIREREVZ+nSpejbty+8vb3RvXt3WFhYYMeOHdJ0bW1t7NmzB9ra2nB2dsb777+P4cOHq10FYWdnh9DQUISHh6NNmzZYvHgx1q5dyx/tiKjcjRgxAgMGDMCiRYtgaWmJevXqwc/PD0+fPpViCl5WZ2tri+3bt+PHH3+ETCbDiBEjADy7laV///4wNDSEUqnEoEGD1C4PDgoKQtu2bbF27VrY2dlJ923KZDJ8++236Nu3LwwMDGBvb4/o6GgkJCTAxcUFderUQefOnXH16tUSt+n69euQyWTYsWMHevbsCQMDA7Rp00bt+33By+pCQkIwe/ZsnDt3TrpVpzJusyl1b3V5eXmYOHEiunTpovaL3dChQ2FjYwMrKyucP38e06ZNQ3x8vHQQqqgegbKyspCVlSW9ZnepRESvrsjISLXXenp6CA4ORnBwcLHz2NjYFLps7nkuLi44e/ZseaRIRPRChw8fhqWlJQ4fPoyEhAQMHjwYbdu2xejRowvFnjlzBsOHD4dSqcTy5cuhr6+PvLw8qTA6cuQIcnJy4Ofnh8GDB6vtIxMSErB9+3bs2LED2tra0vi5c+diyZIlWLJkCaZNm4ahQ4eicePGCAwMRKNGjfDhhx/C398f+/bt06hdn376KRYtWoTXXnsNn376Kd577z0kJCRAR0e9LBk8eDAuXryIsLAwHDx4EAAq5XLBUhdHfn5+uHjxIo4dO6Y2fsyYMdL/HR0dYWlpCVdXV1y9ehVNmjQpfaYvwe5SiYiIiKi2qFu3Lr755htoa2ujRYsW8PLyQkRERJHFkampKRQKBfT19aVbW8LDw3HhwgUkJibC2toaAPDjjz+iZcuWOHPmDDp06ADg2aV0P/74Y6HL9EaOHIlBgwYBAKZNmwZnZ2d89tln0tnyjz/+GCNHjtS4XZ988gm8vLwAALNnz0bLli2RkJCAFi1aqMXp6+vD0NAQOjo6xd6uUxFKdVmdv78/9uzZg8OHD6Nhw4YvjO3YsSOAZ1UpUHE9ArG7VCIiIiKqLVq2bKl2JsfS0hKpqaklnv/y5cuwtraWCiMAcHBwgLGxMS5fviyNs7GxKVQYAUDr1q2l/+df0eXo6Kg27smTJxpfrVVwuZaWlgCgUbsqmkbFkRAC/v7+2LlzJw4dOgQ7O7uXzpPfu0R+452dnXHhwgW1jVBUj0ARERFqy3lZj0DsLpWIiIiIqjOlUinds19QWlpaoUvGdHV11V7LZDLk5eWVe04Fe7wrbv0ymazYcZrmVB7LqEgaFUd+fn7YsGEDNm3aBCMjIyQnJyM5ORmPHz8G8KyXjLlz5yImJgbXr1/H7t27MXz4cHTv3l2qEgv2CHTu3Dns37+/yB6Brl27hqlTp+LPP//EypUrsXXrVkyaNKmcm09EREREVDmaN2+OP/74o9D4P/74A82aNSvXddnb2+PmzZtqV1NdunQJaWlp0gmJ6k4ulyM3N7dS16lRcbRq1Sqkp6fDxcUFlpaW0rBlyxYAzxpw8OBBuLu7o0WLFpg8eTK8vb3x22+/Sctgj0BERERE9CoaN24c/vrrL0yYMAHnz59HfHw8lixZgp9//hmTJ08u13W5ubnB0dERw4YNwx9//IHTp09j+PDh6NGjB9q3b1+u66ootra2SExMRGxsLP755x+1ztcqikYdMgghXjjd2toaR44ceely2CMQEREREb1qGjdujKioKHz66adwc3NDdnY2WrRogW3btsHT07Nc1yWTyfDrr79i/Pjx6N69O7S0tODp6YkVK1aU63oqkre3t9T1d1paGtavXy91U15RZOJlFU8NlZGRAZVKhfT0dN5/RNWO7fRQXNcbqvGTtYlqAu5/i8dtQ7VC0P/fG1OFx7AnT54gMTFR7dk8RC/6XJR0/1umh8ASERERERHVFiyOiIiIiIiIwOKIiIiIiIgIAIsjIiIiIiIiACyOiIiIiIiIALA4IiIiIqIaqpZ2ukylVB6fBxZHRERERFSj6OrqAgAePXpUxZlQdZL/ecj/fJSGRg+BJSIiIiKqatra2jA2NkZqaioAwMDAADKZrIqzoqoihMCjR4+QmpoKY2NjaGtrl3pZLI6IiIiIqMaxsLAAAKlAIjI2NpY+F6XF4oiIiIiIahyZTAZLS0uYmZnh6dOnVZ0OVTFdXd0ynTHKx+KIiIiIiGosbW3tcvlSTASwQwYiIiIiIiIALI6IiIiIiIgAsDgiouooSFXVGRAREdEriMURERERERERWBwRURWwnR5a1SkQERERFcLiiIiIiIiICCyOiIiIiIiIALA4IiIiIiIiAsDiiIiIiIiICACLIyIiIiIiIgAsjoiIiIiIiACwOCIiIiIiIgKgYXE0f/58dOjQAUZGRjAzM8OAAQMQHx+vFvPkyRP4+fmhXr16MDQ0hLe3N1JSUtRikpKS4OXlBQMDA5iZmWHKlCnIyclRi4mMjMTrr78OhUKBpk2bIiQkpHQtJCIiIiIiKgGNiqMjR47Az88PJ0+eRHh4OJ4+fQp3d3c8fPhQipk0aRJ+++03bNu2DUeOHMHt27fxzjvvSNNzc3Ph5eWF7OxsnDhxAj/88ANCQkIwc+ZMKSYxMRFeXl7o2bMnYmNjMXHiRIwaNQr79+8vhyYTEREREREVpqNJcFhYmNrrkJAQmJmZISYmBt27d0d6ejq+//57bNq0Cb169QIArF+/Hvb29jh58iQ6deqEAwcO4NKlSzh48CDMzc3Rtm1bzJ07F9OmTUNQUBDkcjlWr14NOzs7LF68GABgb2+PY8eOYenSpfDw8CinphMREREREf1Pme45Sk9PBwCYmJgAAGJiYvD06VO4ublJMS1atECjRo0QHR0NAIiOjoajoyPMzc2lGA8PD2RkZCAuLk6KKbiM/Jj8ZRQlKysLGRkZagMREdV+q1atQuvWraFUKqFUKuHs7Ix9+/ZJ03m5NxERlVSpi6O8vDxMnDgRXbp0QatWrQAAycnJkMvlMDY2Vos1NzdHcnKyFFOwMMqfnj/tRTEZGRl4/PhxkfnMnz8fKpVKGqytrUvbNCIiqkEaNmyIL7/8EjExMfj999/Rq1cv9O/fX/rBjZd7ExFRSWl0WV1Bfn5+uHjxIo4dO1ae+ZRaYGAgAgICpNcZGRkskIiIXgH9+vVTez1v3jysWrUKJ0+eRMOGDXm5NxERlVipzhz5+/tjz549OHz4MBo2bCiNt7CwQHZ2NtLS0tTiU1JSYGFhIcU8fzlD/uuXxSiVSujr6xeZk0KhkC6pyB+IiOjVkpubi82bN+Phw4dwdnau0su9AV7yTURU02hUHAkh4O/vj507d+LQoUOws7NTm+7k5ARdXV1ERERI4+Lj45GUlARnZ2cAgLOzMy5cuIDU1FQpJjw8HEqlEg4ODlJMwWXkx+Qvg4iIqKALFy7A0NAQCoUCY8eOxc6dO+Hg4FCll3sDvOSbiKim0ag48vPzw4YNG7Bp0yYYGRkhOTkZycnJ0oFBpVLB19cXAQEBOHz4MGJiYjBy5Eg4OzujU6dOAAB3d3c4ODjggw8+wLlz57B//37MmDEDfn5+UCgUAICxY8fi2rVrmDp1Kv7880+sXLkSW7duxaRJk8q5+UREVBs0b94csbGxOHXqFMaNGwcfHx9cunSpqtNCYGAg0tPTpeHmzZtVnRIREb2ARvccrVq1CgDg4uKiNn79+vUYMWIEAGDp0qXQ0tKCt7c3srKy4OHhgZUrV0qx2tra2LNnD8aNGwdnZ2fUqVMHPj4+mDNnjhRjZ2eH0NBQTJo0CcuXL0fDhg2xdu1aXtdNRERFksvlaNq0KYBnVzGcOXMGy5cvx+DBg6XLvQuePXr+cu/Tp0+rLa88LvcGnl3ynf/DHxERVX8aFUdCiJfG6OnpITg4GMHBwcXG2NjYYO/evS9cjouLC86ePatJekRERACe9aialZWldrm3t7c3gKIv9543bx5SU1NhZmYGoOjLvZ8/bvFybyKi2qfUvdURERFVB4GBgejduzcaNWqEBw8eYNOmTYiMjMT+/fvVLvc2MTGBUqnE+PHji73ce8GCBUhOTi7ycu9vvvkGU6dOxYcffohDhw5h69atCA0NrcqmExFROWNxRERENVpqaiqGDx+OO3fuQKVSoXXr1ti/fz/efPNNALzcm6g82U4PxXW9qs6CqOKwOCIiohrt+++/f+F0Xu5NREQlVarnHBEREREREdU2LI6IiIiIiIjA4oiIiIiIiAgAiyMiIiIiIiIALI6IiIiIiIgAsDgiIiIiIiICwOKIiIiIiIgIAIsjIiIiIiIiACyOiIiIiIiIALA4IiIiIiIiAsDiiIiIiIiICACLIyIiIiIiIgAsjoiIiIiIiACwOCIiIiIiIgLA4oiIiIiIiAgAiyMiIiIiIiIALI6IiIiIiIgAsDgiIiIiIiICwOKIiIiIiIgIAIsjIiIiIiIiAKUojqKiotCvXz9YWVlBJpNh165datNHjBgBmUymNnh6eqrF3L9/H8OGDYNSqYSxsTF8fX2RmZmpFnP+/Hl069YNenp6sLa2xoIFCzRvHRERERERUQlpXBw9fPgQbdq0QXBwcLExnp6euHPnjjT8/PPPatOHDRuGuLg4hIeHY8+ePYiKisKYMWOk6RkZGXB3d4eNjQ1iYmKwcOFCBAUFYc2aNZqmS0REREREVCI6ms7Qu3dv9O7d+4UxCoUCFhYWRU67fPkywsLCcObMGbRv3x4AsGLFCvTp0weLFi2ClZUVNm7ciOzsbKxbtw5yuRwtW7ZEbGwslixZolZEERERERERlZcKuecoMjISZmZmaN68OcaNG4d79+5J06Kjo2FsbCwVRgDg5uYGLS0tnDp1Sorp3r075HK5FOPh4YH4+Hj8+++/Ra4zKysLGRkZagMREREREVFJlXtx5OnpiR9//BERERH46quvcOTIEfTu3Ru5ubkAgOTkZJiZmanNo6OjAxMTEyQnJ0sx5ubmajH5r/Njnjd//nyoVCppsLa2Lu+mERERERFRLabxZXUvM2TIEOn/jo6OaN26NZo0aYLIyEi4urqW9+okgYGBCAgIkF5nZGSwQCIiIiIiohKr8K68GzdujPr16yMhIQEAYGFhgdTUVLWYnJwc3L9/X7pPycLCAikpKWox+a+Lu5dJoVBAqVSqDURERERERCVV4cXRrVu3cO/ePVhaWgIAnJ2dkZaWhpiYGCnm0KFDyMvLQ8eOHaWYqKgoPH36VIoJDw9H8+bNUbdu3YpOmYiIiIiIXkEaF0eZmZmIjY1FbGwsACAxMRGxsbFISkpCZmYmpkyZgpMnT+L69euIiIhA//790bRpU3h4eAAA7O3t4enpidGjR+P06dM4fvw4/P39MWTIEFhZWQEAhg4dCrlcDl9fX8TFxWHLli1Yvny52mVzRERERERE5Unj4uj3339Hu3bt0K5dOwBAQEAA2rVrh5kzZ0JbWxvnz5/HW2+9hWbNmsHX1xdOTk44evQoFAqFtIyNGzeiRYsWcHV1RZ8+fdC1a1e1ZxipVCocOHAAiYmJcHJywuTJkzFz5kx2401ERERERBVG4w4ZXFxcIIQodvr+/ftfugwTExNs2rTphTGtW7fG0aNHNU2PqGoEqYCg9KrOgoiIiIjKoMLvOSIiIiIiIqoJWBwRERERUZnYTg+F7fTQqk6DqMxYHBEREREREYHFERER1XDz589Hhw4dYGRkBDMzMwwYMADx8fFqMU+ePIGfnx/q1asHQ0NDeHt7F3qeXlJSEry8vGBgYAAzMzNMmTIFOTk5ajGRkZF4/fXXoVAo0LRpU4SEhFR084iIqBKxOCIiohrtyJEj8PPzw8mTJxEeHo6nT5/C3d0dDx8+lGImTZqE3377Ddu2bcORI0dw+/ZtvPPOO9L03NxceHl5ITs7GydOnMAPP/yAkJAQzJw5U4pJTEyEl5cXevbsidjYWEycOBGjRo0qUUdERERUM2jcWx0REVF1EhYWpvY6JCQEZmZmiImJQffu3ZGeno7vv/8emzZtQq9evQAA69evh729PU6ePIlOnTrhwIEDuHTpEg4ePAhzc3O0bdsWc+fOxbRp0xAUFAS5XI7Vq1fDzs4OixcvBvDsuX3Hjh3D0qVLpWf5ERFRzcYzR0REVKukpz/rVt/ExAQAEBMTg6dPn8LNzU2KadGiBRo1aoTo6GgAQHR0NBwdHWFubi7FeHh4ICMjA3FxcVJMwWXkx+QvoyhZWVnIyMhQG4iIqPpicURERLVGXl4eJk6ciC5duqBVq1YAgOTkZMjlchgbG6vFmpubIzk5WYopWBjlT8+f9qKYjIwMPH78uMh85s+fD5VKJQ3W1tZlbiMREVUcFkdERFRr+Pn54eLFi9i8eXNVpwIACAwMRHp6ujTcvHmzqlMiIqIX4D1HRERUK/j7+2PPnj2IiopCw4YNpfEWFhbIzs5GWlqa2tmjlJQUWFhYSDGnT59WW15+b3YFY57v4S4lJQVKpRL6+vpF5qRQKKBQKMrcNiIiqhw8c0RERDWaEAL+/v7YuXMnDh06BDs7O7XpTk5O0NXVRUREhDQuPj4eSUlJcHZ2BgA4OzvjwoULSE1NlWLCw8OhVCrh4OAgxRRcRn5M/jKIiKjm45kjIiKq0fz8/LBp0yb8+uuvMDIyku4RUqlU0NfXh0qlgq+vLwICAmBiYgKlUonx48fD2dkZnTp1AgC4u7vDwcEBH3zwARYsWIDk5GTMmDEDfn5+0pmfsWPH4ptvvsHUqVPx4Ycf4tChQ9i6dStCQ0OrrO1ERFS+eOaIiIhqtFWrViE9PR0uLi6wtLSUhi1btkgxS5cuRd++feHt7Y3u3bvDwsICO3bskKZra2tjz5490NbWhrOzM95//30MHz4cc+bMkWLs7OwQGhqK8PBwtGnTBosXL8batWvZjTcRUS3CM0dERFSjCSFeGqOnp4fg4GAEBwcXG2NjY4O9e/e+cDkuLi44e/asxjkSEVHNwDNHREREREREYHFEREREREQEgMXRK8l2eihsp/MGYiIiIiKiglgcERERERERgcURERERERERABZHREREREREAFgcERERERERAWBxREREREREBIDFEREREREREQAWR0RERERERABKURxFRUWhX79+sLKygkwmw65du9SmCyEwc+ZMWFpaQl9fH25ubrhy5YpazP379zFs2DAolUoYGxvD19cXmZmZajHnz59Ht27doKenB2trayxYsEDz1hEREREREZWQxsXRw4cP0aZNGwQHBxc5fcGCBfj666+xevVqnDp1CnXq1IGHhweePHkixQwbNgxxcXEIDw/Hnj17EBUVhTFjxkjTMzIy4O7uDhsbG8TExGDhwoUICgrCmjVrStFEIiIiIiKil9PRdIbevXujd+/eRU4TQmDZsmWYMWMG+vfvDwD48ccfYW5ujl27dmHIkCG4fPkywsLCcObMGbRv3x4AsGLFCvTp0weLFi2ClZUVNm7ciOzsbKxbtw5yuRwtW7ZEbGwslixZolZEERERERERlZdyvecoMTERycnJcHNzk8apVCp07NgR0dHRAIDo6GgYGxtLhREAuLm5QUtLC6dOnZJiunfvDrlcLsV4eHggPj4e//77b5HrzsrKQkZGhtpARERERERUUuVaHCUnJwMAzM3N1cabm5tL05KTk2FmZqY2XUdHByYmJmoxRS2j4DqeN3/+fKhUKmmwtrYue4OIiIiIiOiVUWt6qwsMDER6ero03Lx5s6pTIiIiIiKiGqRciyMLCwsAQEpKitr4lJQUaZqFhQVSU1PVpufk5OD+/ftqMUUto+A6nqdQKKBUKtUGIiIiIiKikirX4sjOzg4WFhaIiIiQxmVkZODUqVNwdnYGADg7OyMtLQ0xMTFSzKFDh5CXl4eOHTtKMVFRUXj69KkUEx4ejubNm6Nu3brlmTIRERERERGAUhRHmZmZiI2NRWxsLIBnnTDExsYiKSkJMpkMEydOxOeff47du3fjwoULGD58OKysrDBgwAAAgL29PTw9PTF69GicPn0ax48fh7+/P4YMGQIrKysAwNChQyGXy+Hr64u4uDhs2bIFy5cvR0BAQLk1nIiIiIiIqCCNu/L+/fff0bNnT+l1fsHi4+ODkJAQTJ06FQ8fPsSYMWOQlpaGrl27IiwsDHp6etI8GzduhL+/P1xdXaGlpQVvb298/fXX0nSVSoUDBw7Az88PTk5OqF+/PmbOnMluvImIiIiIqMJoXBy5uLhACFHsdJlMhjlz5mDOnDnFxpiYmGDTpk0vXE/r1q1x9OhRTdMjIiIiIiIqlVrTWx0REREREVFZsDgiIiIiIiICiyMiIiIiIiIALI6IiIiIiIgAsDgiIiIiIiICwOKIiIiIiIgIAIsjIiIiIiIiACyOiIiIiIiIALA4IiIiIiIiAsDiiIiIiIjKme300KpOgahUWBwRERERERGBxREREREREREAFkdERERUXoJUzwYiohqKxREREdVoUVFR6NevH6ysrCCTybBr1y616UIIzJw5E5aWltDX14ebmxuuXLmiFnP//n0MGzYMSqUSxsbG8PX1RWZmplrM+fPn0a1bN+jp6cHa2hoLFiyo6KYREVUPr9APHyyOiKh0XpGdJFV/Dx8+RJs2bRAcHFzk9AULFuDrr7/G6tWrcerUKdSpUwceHh548uSJFDNs2DDExcUhPDwce/bsQVRUFMaMGSNNz8jIgLu7O2xsbBATE4OFCxciKCgIa9asqfD2ERFR5dGp6gSIiIjKonfv3ujdu3eR04QQWLZsGWbMmIH+/fsDAH788UeYm5tj165dGDJkCC5fvoywsDCcOXMG7du3BwCsWLECffr0waJFi2BlZYWNGzciOzsb69atg1wuR8uWLREbG4slS5aoFVFERFSz8cwRERHVWomJiUhOToabm5s0TqVSoWPHjoiOjgYAREdHw9jYWCqMAMDNzQ1aWlo4deqUFNO9e3fI5XIpxsPDA/Hx8fj333+LXX9WVhYyMjLUBiIiqr5YHBERUa2VnJwMADA3N1cbb25uLk1LTk6GmZmZ2nQdHR2YmJioxRS1jILrKMr8+fOhUqmkwdraumwNIiKiCsXiiIiIqIIEBgYiPT1dGm7evFnVKRER0QuwOCIiolrLwsICAJCSkqI2PiUlRZpmYWGB1NRUtek5OTm4f/++WkxRyyi4jqIoFAoolUq1gYiIqi8WR0REVGvZ2dnBwsICERER0riMjAycOnUKzs7OAABnZ2ekpaUhJiZGijl06BDy8vLQsWNHKSYqKgpPnz6VYsLDw9G8eXPUrVu3klpDREQVjcURERHVaJmZmYiNjUVsbCyAZ50wxMbGIikpCTKZDBMnTsTnn3+O3bt348KFCxg+fDisrKwwYMAAAIC9vT08PT0xevRonD59GsePH4e/vz+GDBkCKysrAMDQoUMhl8vh6+uLuLg4bNmyBcuXL0dAQEAVtZqIiCoCu/ImIqIa7ffff0fPnj2l1/kFi4+PD0JCQjB16lQ8fPgQY8aMQVpaGrp27YqwsDDo6elJ82zcuBH+/v5wdXWFlpYWvL298fXXX0vTVSoVDhw4AD8/Pzg5OaF+/fqYOXMmu/EmIqplyv3MUVBQEGQymdrQokULafqTJ0/g5+eHevXqwdDQEN7e3oWu405KSoKXlxcMDAxgZmaGKVOmICcnp7xTJSKiWsDFxQVCiEJDSEgIAEAmk2HOnDlITk7GkydPcPDgQTRr1kxtGSYmJti0aRMePHiA9PR0rFu3DoaGhmoxrVu3xtGjR/HkyRPcunUL06ZNq6wmEhFRJamQM0ctW7bEwYMH/7cSnf+tZtKkSQgNDcW2bdugUqng7++Pd955B8ePHwcA5ObmwsvLCxYWFjhx4gTu3LmD4cOHQ1dXF1988UVFpEtERERERFQxxZGOjk6Rvfekp6fj+++/x6ZNm9CrVy8AwPr162Fvb4+TJ0+iU6dOOHDgAC5duoSDBw/C3Nwcbdu2xdy5czFt2jQEBQWpPYCPiIiIiIiovFRIhwxXrlyBlZUVGjdujGHDhiEpKQkAEBMTg6dPn6o9qbxFixZo1KiR2pPKHR0d1R625+HhgYyMDMTFxRW7Tj6FnIiIiIiIyqLci6OOHTsiJCQEYWFhWLVqFRITE9GtWzc8ePAAycnJkMvlMDY2Vpvn+SeV8ynkRERERERU2cq9OOrduzfeffddtG7dGh4eHti7dy/S0tKwdevW8l6VGj6FnKhi2U4PrbiFB6meDURERERVqMKfc2RsbIxmzZohISEBFhYWyM7ORlpamlrM808q51PIiYiIiIioslV4cZSZmYmrV6/C0tISTk5O0NXVVXtSeXx8PJKSktSeVH7hwgWkpqZKMeHh4VAqlXBwcKjodInKjmdBiIiIiGqkcu+t7pNPPkG/fv1gY2OD27dvY9asWdDW1sZ7770HlUoFX19fBAQEwMTEBEqlEuPHj4ezszM6deoEAHB3d4eDgwM++OADLFiwAMnJyZgxYwb8/PygUCjKO10iIiIiIiIAFVAc3bp1C++99x7u3bsHU1NTdO3aFSdPnoSpqSkAYOnSpdLTx7OysuDh4YGVK1dK82tra2PPnj0YN24cnJ2dUadOHfj4+GDOnDnlnSoREREREZGk3IujzZs3v3C6np4egoODERwcXGyMjY0N9u7dW96pERERERERFavC7zkiIiIiIiKqCVgcERERERERgcURERERERERABZHRJphF91EREREtRaLIyIiIiIiIrA4IiIiInpl2E4PreoUiKo1FkdERERERERgcUT0SuIvh0RERESFsTgiIiIiIipH/BGy5mJxRJXOdnoodxq1CN9LIiIiqi1YHJHGqkNxU9Xrr9WCVOyynIiIiF5JLI6ISosFBBEREVGtwuKIiIiIiIgILI6IiIjoFcVLtInoeSyOiIiIiIiIwOKIiIiIiIgIAIsjIiIiqi7YWyZR+eHfUqmwOCKqpapDl+tERERVgcc/Ki0WR0SlUBN3ujUxZyIiIqLKxOKIai0WA0RERESkCRZHRK8qXotMRFTzvYr3ab2KbaZKw+KIXkmv7FklHkyIqDxwXwLgFT6W/L+afm9rTc+fKgaLI6pWuJPSnO30UOmLCrcfEdGriV/0qVLV4h9IWBxRrVLWA0N1OrCU+kBXhssNqlP7iYhqqiotVGrxl1aiylCti6Pg4GDY2tpCT08PHTt2xOnTp6s6JaqFamJBUO458/ptohLjsamclXXfU4P3XwX35RVSUNXQ7SIpmH9Nb0sFqYnfYaq7alscbdmyBQEBAZg1axb++OMPtGnTBh4eHkhNTa3q1KgGeqV/xSvP9VfXZRFVEh6baoby3udXp2Xxy3ARyqmI0nTblvVzVqb5y+NHBSpStS2OlixZgtGjR2PkyJFwcHDA6tWrYWBggHXr1lV1aq+MmrIDrowdy4t2YNXpoFlZ6yw0Tzn9cltlRWwN/uWZKhePTZWsAn6QKW7/VXD/U5p9UbntvwrmWdyX/orcZ5VmuSWZ50Uxlbj/LZdjXhnX/8LlFfGev3T9VX2GrZYdP3WqOoGiZGdnIyYmBoGBgdI4LS0tuLm5ITo6ush5srKykJWVJb1OT08HAGRkZFRsslWg1az9AICLsz2KnFbU+ILysh4BePm2yct6VGTMi+YvuP7n/5+f8/PzF4wruM7i5n8+rqT/L7jOvKxHyJAJICOj2HkAAPMb/v/475/NX3CeIv7fatZ+XNQTz3KetO1ZznqiwP99gcBbavNI68kfH6hUX2egEgi89f/LLjB/cW2RCfU2vyTn5+fJ/7+Uc8Ft/pL5C84jvWf/n3OhdhaxzZ7PueA8BRX6nP//+9TqyfdqOZdY1rP1oxbuL6pC/mdTCFHFmZSvV+LY9P9/S8//zRb6f1Yxf6PP/y0VN39xy3p+/iLWU3Bf+Pw+96KeL4Di9p8F9ln/P77IfWagstD8BecptC8uYp8t/f/548lzyypy/hcdW4rY5xa3/yw4T3E5I/BW4fc8q8A8RRzPizvOFHmcLdj+gu/l84p9n0XRn4UXfU6yCr/PUvv/fzsXd5wtNM9LvpsU+X3m+e1cxPrz1/miz2mRn9ki3qfiPieFtl8x73PBbV7k//Hs2Jr/OXvRNi/0/j1/LC7ieF6ZSnxsEtXQ33//LQCIEydOqI2fMmWKeOONN4qcZ9asWQIABw4cOHCoJsPNmzcr45BRaXhs4sCBA4eaP7zs2FQtzxyVRmBgIAICAqTXeXl5uH//PurVqweZTFaFmZWvjIwMWFtb4+bNm1AqlVWdToWo7W1k+2q+2t7GsrZPCIEHDx7AysqqArKrWSry2FTbP4cVjduvbLj9So/brmxKu/1KemyqlsVR/fr1oa2tjZSUFLXxKSkpsLCwKHIehUIBhUKhNs7Y2LiiUqxySqWy1v9B1fY2sn01X21vY1nap1Kpyjmbqlddj021/XNY0bj9yobbr/S47cqmNNuvJMematkhg1wuh5OTEyIiIqRxeXl5iIiIgLOzcxVmRkREryoem4iIar9qeeYIAAICAuDj44P27dvjjTfewLJly/Dw4UOMHDmyqlMjIqJXFI9NRES1W7UtjgYPHoy7d+9i5syZSE5ORtu2bREWFgZzc/OqTq1KKRQKzJo1q9BlGrVJbW8j21fz1fY21vb2lUV1OjbxfSobbr+y4fYrPW67sqno7ScTopb1tUpERERERFQK1fKeIyIiIiIiosrG4oiIiIiIiAgsjoiIiIiIiACwOCIiIiIiIgLA4qhGuH//PoYNGwalUgljY2P4+voiMzOzRPMKIdC7d2/IZDLs2rWrYhMtJU3bd//+fYwfPx7NmzeHvr4+GjVqhAkTJiA9Pb0Ss36x4OBg2NraQk9PDx07dsTp06dfGL9t2za0aNECenp6cHR0xN69eysp09LRpH3fffcdunXrhrp166Ju3bpwc3N76faoDjR9D/Nt3rwZMpkMAwYMqNgEy0jT9qWlpcHPzw+WlpZQKBRo1qxZtf+c1kbz5s1D586dYWBgUOKHyQohMHPmTFhaWkJfXx9ubm64cuVKxSZaTZXmeOri4gKZTKY2jB07tpIyrlq1/VhWkTTZdiEhIYU+Y3p6epWYbfURFRWFfv36wcrKqsTfXSMjI/H6669DoVCgadOmCAkJKVsSgqo9T09P0aZNG3Hy5Elx9OhR0bRpU/Hee++VaN4lS5aI3r17CwBi586dFZtoKWnavgsXLoh33nlH7N69WyQkJIiIiAjx2muvCW9v70rMunibN28WcrlcrFu3TsTFxYnRo0cLY2NjkZKSUmT88ePHhba2tliwYIG4dOmSmDFjhtDV1RUXLlyo5MxLRtP2DR06VAQHB4uzZ8+Ky5cvixEjRgiVSiVu3bpVyZmXnKZtzJeYmCgaNGggunXrJvr37185yZaCpu3LysoS7du3F3369BHHjh0TiYmJIjIyUsTGxlZy5jRz5kyxZMkSERAQIFQqVYnm+fLLL4VKpRK7du0S586dE2+99Zaws7MTjx8/rthkq6HSHE979OghRo8eLe7cuSMN6enplZRx1antx7KKpOm2W79+vVAqlWqfseTk5ErOunrYu3ev+PTTT8WOHTtK9N312rVrwsDAQAQEBIhLly6JFStWCG1tbREWFlbqHFgcVXOXLl0SAMSZM2ekcfv27RMymUz8/fffL5z37NmzokGDBuLOnTvVtjgqS/sK2rp1q5DL5eLp06cVkaZG3njjDeHn5ye9zs3NFVZWVmL+/PlFxg8aNEh4eXmpjevYsaP46KOPKjTP0tK0fc/LyckRRkZG4ocffqioFMusNG3MyckRnTt3FmvXrhU+Pj7VujjStH2rVq0SjRs3FtnZ2ZWVIr3E+vXrS1Qc5eXlCQsLC7Fw4UJpXFpamlAoFOLnn3+uwAyrn9Ieb3r06CE+/vjjSsiweqntx7KKpOm2K+nf86umJN9dp06dKlq2bKk2bvDgwcLDw6PU6+VlddVcdHQ0jI2N0b59e2mcm5sbtLS0cOrUqWLne/ToEYYOHYrg4GBYWFhURqqlUtr2PS89PR1KpRI6OlX7XOPs7GzExMTAzc1NGqelpQU3NzdER0cXOU90dLRaPAB4eHgUG1+VStO+5z169AhPnz6FiYlJRaVZJqVt45w5c2BmZgZfX9/KSLPUStO+3bt3w9nZGX5+fjA3N0erVq3wxRdfIDc3t7LSplJKTExEcnKy2vutUqnQsWPHarmPqUhlOd5s3LgR9evXR6tWrRAYGIhHjx5VdLpVqrYfyypSaY8hmZmZsLGxgbW1Nfr374+4uLjKSLfGq4jPXdV+k6SXSk5OhpmZmdo4HR0dmJiYIDk5udj5Jk2ahM6dO6N///4VnWKZlLZ9Bf3zzz+YO3cuxowZUxEpauSff/5Bbm4uzM3N1cabm5vjzz//LHKe5OTkIuNL2v7KVJr2PW/atGmwsrIqtDOrLkrTxmPHjuH7779HbGxsJWRYNqVp37Vr13Do0CEMGzYMe/fuRUJCAv7zn//g6dOnmDVrVmWkTaWUvx+pKfuYilTa483QoUNhY2MDKysrnD9/HtOmTUN8fDx27NhR0SlXmdp+LKtIpdl2zZs3x7p169C6dWukp6dj0aJF6Ny5M+Li4tCwYcPKSLvGKu5zl5GRgcePH0NfX1/jZfLMURWZPn16oZvvnh9K+mXzebt378ahQ4ewbNmy8k1aAxXZvoIyMjLg5eUFBwcHBAUFlT1xqlBffvklNm/ejJ07d9aam00fPHiADz74AN999x3q169f1elUiLy8PJiZmWHNmjVwcnLC4MGD8emnn2L16tVVnVqtUFn7y9qqorffmDFj4OHhAUdHRwwbNgw//vgjdu7ciatXr5ZjK+hV5uzsjOHDh6Nt27bo0aMHduzYAVNTU3z77bdVndoriWeOqsjkyZMxYsSIF8Y0btwYFhYWSE1NVRufk5OD+/fvF3u53KFDh3D16tVCPRl5e3ujW7duiIyMLEPmJVOR7cv34MEDeHp6wsjICDt37oSurm5Z0y6z+vXrQ1tbGykpKWrjU1JSim2PhYWFRvFVqTTty7do0SJ8+eWXOHjwIFq3bl2RaZaJpm28evUqrl+/jn79+knj8vLyADz7VTo+Ph5NmjSp2KQ1UJr30NLSErq6utDW1pbG2dvbIzk5GdnZ2ZDL5RWac21X0v1laeS/pykpKbC0tJTGp6SkoG3btqVaZnVTGcebgjp27AgASEhIqFZ/2+Wpth/LKlJZjpP5dHV10a5dOyQkJFREirVKcZ87pVJZqrNGAIujKmNqagpTU9OXxjk7OyMtLQ0xMTFwcnIC8Kz4ycvLk3bQz5s+fTpGjRqlNs7R0RFLly5V+wJXkSqyfcCzM0YeHh5QKBTYvXt3tTkLIZfL4eTkhIiICKkr57y8PERERMDf37/IeZydnREREYGJEydK48LDw+Hs7FwJGWumNO0DgAULFmDevHnYv3+/2vX+1ZGmbWzRogUuXLigNm7GjBl48OABli9fDmtr68pIu8RK8x526dIFmzZtQl5eHrS0nl1w8Ndff8HS0pKFUTko6f6yNOzs7GBhYYGIiAipGMrIyMCpU6cwbty4CllnZavo483z8i+fLVhs1ja1/VhWkUp7nCwoNzcXFy5cQJ8+fSow09rB2dm5UJfxZf7clborB6o0np6eol27duLUqVPi2LFj4rXXXlPrevTWrVuiefPm4tSpU8UuA9W0tzohNG9fenq66Nixo3B0dBQJCQlqXV/m5ORUVTMkmzdvFgqFQoSEhIhLly6JMWPGCGNjY6lbzg8++EBMnz5dij9+/LjQ0dERixYtEpcvXxazZs2q1t2fatq+L7/8UsjlcvHLL7+ovVcPHjyoqia8lKZtfF51761O0/YlJSUJIyMj4e/vL+Lj48WePXuEmZmZ+Pzzz6uqCa+sGzduiLNnz4rZs2cLQ0NDcfbsWXH27Fm1v6fmzZuLHTt2SK+//PJLYWxsLH799Vdx/vx50b9//1e6K29NjjcJCQlizpw54vfffxeJiYni119/FY0bNxbdu3evqiZUmtp+LKtImm672bNni/3794urV6+KmJgYMWTIEKGnpyfi4uKqqglV5sGDB9J+DYBYsmSJOHv2rLhx44YQQojp06eLDz74QIrP78p7ypQp4vLlyyI4OJhdeb8K7t27J9577z1haGgolEqlGDlypNqBMDExUQAQhw8fLnYZ1bk40rR9hw8fFgCKHBITE6umEc9ZsWKFaNSokZDL5eKNN94QJ0+elKb16NFD+Pj4qMVv3bpVNGvWTMjlctGyZUsRGhpayRlrRpP22djYFPlezZo1q/IT14Cm72FB1b04EkLz9p04cUJ07NhRKBQK0bhxYzFv3rxq8WPEq8bHx6fIv6eC+38AYv369dLrvLw88dlnnwlzc3OhUCiEq6uriI+Pr/zkqwFNjzdJSUmie/fuwsTERCgUCtG0aVMxZcqUV+I5R0LU/mNZRdJk202cOFGKNTc3F3369BF//PFHFWRd9Yr7jpe/vXx8fESPHj0KzdO2bVshl8tF48aN1fZ/pSETQojSn3ciIiIiIiKqHdhbHREREREREVgcERERERERAWBxREREREREBIDFEREREREREQAWR0RERERERABYHBEREREREQFgcURERERERASAxRFVMy4uLpg4cWKlrS8kJATGxsaVtj4iIqodeLwiqp1YHFGlGzFiBGQyWaEhISEBO3bswNy5c6VYW1tbLFu2TG3+yj5AyGQy6Onp4caNG2rjBwwYgBEjRpR4OZGRkZDJZEhLSytzTpoelK9fvw6ZTIbY2Ngyr7uyjBgxAgMGDKjqNIjoFcbjVVqZc3JxcSlyG+bk5JR52UVt87KYN28eOnfuDAMDAxairzAWR1QlPD09cefOHbXBzs4OJiYmMDIyqur0CpHJZJg5c2ZVp1EtPH36tKpTICKqNDxeld3o0aMLbUMdHZ2qTkuSnZ0t/fvuu+9i3LhxVZwRVSUWR1QlFAoFLCws1AZtbW21MyIuLi64ceMGJk2aJP3SFBkZiZEjRyI9PV0aFxQUBADIysrCJ598ggYNGqBOnTro2LEjIiMj1dYbEhKCRo0awcDAAG+//Tbu3btXonz9/f2xYcMGXLx4sdiYrKwsTJgwAWZmZtDT00PXrl1x5swZAM/O3PTs2RMAULduXchkMulXvLy8PMyfPx92dnbQ19dHmzZt8Msvv5R8Y+LZr2dffPEFPvzwQxgZGaFRo0ZYs2aNNN3Ozg4A0K5dO8hkMri4uEjT1q5dC3t7e+jp6aFFixZYuXKlNC3/jNOWLVvQo0cP6OnpYePGjQCAdevWoWXLllAoFLC0tIS/v780X1paGkaNGgVTU1MolUr06tUL586dk6YHBQWhbdu2+Pbbb2FtbQ0DAwMMGjQI6enp0vQffvgBv/76q9p7n52dDX9/f1haWkJPTw82NjaYP3++RtuKiEgTPF6V/XhlYGBQaBsCwLRp09CsWTMYGBigcePG+Oyzzwr9APfbb7+hQ4cO0NPTQ/369fH2228DKHqb59u+fbt0fLK1tcXixYvVlmlra4u5c+di+PDhUCqVGDNmDABg9uzZmDRpEhwdHYtsx7///othw4bB1NQU+vr6eO2117B+/fqXtp9qGEFUyXx8fET//v2LnNajRw/x8ccfCyGEuHfvnmjYsKGYM2eOuHPnjrhz547IysoSy5YtE0qlUhr34MEDIYQQo0aNEp07dxZRUVEiISFBLFy4UCgUCvHXX38JIYQ4efKk0NLSEl999ZWIj48Xy5cvF8bGxkKlUr0wXwBi586d4q233hJeXl7S+P79+wsfHx/p9YQJE4SVlZXYu3eviIuLEz4+PqJu3bri3r17IicnR2zfvl0AEPHx8eLOnTsiLS1NCCHE559/Llq0aCHCwsLE1atXxfr164VCoRCRkZHF5lRwOwkhhI2NjTAxMRHBwcHiypUrYv78+UJLS0v8+eefQgghTp8+LQCIgwcPijt37oh79+4JIYTYsGGDsLS0FNu3bxfXrl0T27dvFyYmJiIkJEQIIURiYqIAIGxtbaWY27dvi5UrVwo9PT2xbNkyER8fL06fPi2WLl0q5ePm5ib69esnzpw5I/766y8xefJkUa9ePWm9s2bNEnXq1BG9evUSZ8+eFUeOHBFNmzYVQ4cOFUII8eDBAzFo0CDh6emp9t4vXLhQWFtbi6ioKHH9+nVx9OhRsWnTphe+f0REpcXjVfkfrwqaO3euOH78uEhMTBS7d+8W5ubm4quvvpKm79mzR2hra4uZM2eKS5cuidjYWPHFF18Uu82FEOL3338XWlpaYs6cOSI+Pl6sX79e6Ovri/Xr10vLtbGxEUqlUixatEgkJCSIhIQEtbzWr19f5Lb28/MTbdu2FWfOnBGJiYkiPDxc7N69u9i2U83E4ogqnY+Pj9DW1hZ16tSRhoEDBwohiv7SX/BLtxBF77Ru3LghtLW1xd9//6023tXVVQQGBgohhHjvvfdEnz591KYPHjy4xAebuLg4oa2tLaKiooQQ6gebzMxMoaurKzZu3CjNl52dLaysrMSCBQuEEEIcPnxYABD//vuvFPPkyRNhYGAgTpw4obZOX19f8d577xWbU1Hb6f3335de5+XlCTMzM7Fq1SohxP+KnLNnz6otp0mTJoWKi7lz5wpnZ2e1+ZYtW6YWY2VlJT799NMiczt69KhQKpXiyZMnhdb17bffCiGeFUfa2tri1q1b0vR9+/YJLS0t6QBX1JeS8ePHi169eom8vLwi101EVJ54vPpXiinL8UpXV1dtGwYEBBQZu3DhQuHk5CS9dnZ2FsOGDSt22UVt86FDh4o333xTbdyUKVOEg4OD2nwDBgwodrnFFUf9+vUTI0eOLHY+qh2qzwWf9Erp2bMnVq1aJb2uU6dOmZZ34cIF5ObmolmzZmrjs7KyUK9ePQDA5cuXpdPx+ZydnREWFlaidTg4OGD48OGYPn06jh8/rjbt6tWrePr0Kbp06SKN09XVxRtvvIHLly8Xu8yEhAQ8evQIb775ptr47OxstGvXrkR55WvdurX0f5lMBgsLC6SmphYb//DhQ1y9ehW+vr4YPXq0ND4nJwcqlUottn379tL/U1NTcfv2bbi6uha53HPnziEzM1Pa7vkeP36Mq1evSq8bNWqEBg0aSK+dnZ2Rl5eH+Ph46ZKL540YMQJvvvkmmjdvDk9PT/Tt2xfu7u7FtpGIqKx4vHqmLMerYcOG4dNPP5Ve53d2sGXLFnz99de4evUqMjMzkZOTA6VSKcXFxsaqHZ9K4vLly+jfv7/auC5dumDZsmXIzc2FtrY2APXjWkmNGzcO3t7e+OOPP+Du7o4BAwagc+fOGi+HqjcWR1Ql6tSpg6ZNm5bb8jIzM6GtrY2YmBhpx5fP0NCw3NYze/ZsNGvWDLt27SqX5WVmZgIAQkND1QoF4Nl17prQ1dVVey2TyZCXl/fSdX/33Xfo2LGj2rTnt2HBLwP6+vovzCMzMxOWlpaFrp8HUObef15//XUkJiZi3759OHjwIAYNGgQ3NzeN79EiIiopHq+eKcvxSqVSFdqG0dHRGDZsGGbPng0PDw+oVCps3rxZ7f6glx1vyqI0RW7v3r1x48YN7N27F+Hh4XB1dYWfnx8WLVpUARlSVWFxRNWaXC5Hbm7uS8e1a9cOubm5SE1NRbdu3Ypclr29PU6dOqU27uTJkxrlY21tDX9/f/z3v/9FkyZNpPFNmjSBXC7H8ePHYWNjA+BZr25nzpyRbtiVy+UAoJa7g4MDFAoFkpKS0KNHD41y0URR6zY3N4eVlRWuXbuGYcOGlXhZRkZGsLW1RUREhHTTbkGvv/46kpOToaOjA1tb22KXk5SUhNu3b8PKygrAs/dCS0sLzZs3l3J+/n0GAKVSicGDB2Pw4MEYOHAgPD09cf/+fZiYmJS4DURE5Y3HK82cOHECNjY2ameUnu+CvHXr1oiIiMDIkSOLXEZR29fe3r7Q2bLjx4+jWbNmhYrR0jA1NYWPjw98fHzQrVs3TJkyhcVRLcPiiKo1W1tbREVFYciQIVAoFKhfvz5sbW2RmZmJiIgItGnTBgYGBmjWrBmGDRuG4cOHY/HixWjXrh3u3r2LiIgItG7dGl5eXpgwYQK6dOmCRYsWoX///ti/f3+JL1EoKDAwEN999x0SExMxePBgAM9+gRo3bhymTJkCExMTNGrUCAsWLMCjR4/g6+sLALCxsYFMJsOePXvQp08f6Ovrw8jICJ988gkmTZqEvLw8dO3aFenp6Th+/DiUSiV8fHzKZTuamZlBX18fYWFhaNiwIfT09KBSqTB79mxMmDABKpUKnp6eyMrKwu+//45///0XAQEBxS4vKCgIY8eOhZmZGXr37o0HDx7g+PHjGD9+PNzc3ODs7IwBAwZgwYIFaNasGW7fvo3Q0FC8/fbb0qUMenp68PHxwaJFi5CRkYEJEyZg0KBB0iV1tra22L9/P+Lj41GvXj2oVCqsWLEClpaWaNeuHbS0tLBt2zZYWFjweRREVOV4vNLsePXaa68hKSkJmzdvRocOHRAaGoqdO3eqxcyaNQuurq5o0qQJhgwZgpycHOzduxfTpk0rdptPnjwZHTp0wNy5czF48GBER0fjm2++UeuJtThJSUm4f/8+kpKSkJubKz0bsGnTpjA0NMTMmTPh5OSEli1bIisrC3v27IG9vb1G7aYaoKpveqJXT0l7/xFCiOjoaNG6dWuhUChEwY/r2LFjRb169QQAMWvWLCHEsxtKZ86cKWxtbYWurq6wtLQUb7/9tjh//rw03/fffy8aNmwo9PX1Rb9+/cSiRYtKfINrQV988YUAoNb7z+PHj8X48eNF/fr1hUKhEF26dBGnT59Wm2/OnDnCwsJCyGQyad68vDyxbNky0bx5c6GrqytMTU2Fh4eHOHLkSLE5leRG4DZt2kjbRgghvvvuO2FtbS20tLREjx49pPEbN24Ubdu2FXK5XNStW1d0795d7NixQwhRfEcOQgixevVqKWdLS0sxfvx4aVpGRoYYP368sLKyErq6usLa2loMGzZMJCUlCSGedcjQpk0bsXLlSmFlZSX09PTEwIEDxf3796VlpKamijfffFMYGhoKAOLw4cNizZo1om3btqJOnTpCqVQKV1dX8ccffxS7nYiIyoLHq/I/XhU0ZcoUUa9ePWFoaCgGDx4sli5dWqiN27dvl45R9evXF++88440rbht/ssvvwgHBwehq6srGjVqJBYuXKi2zKKOmUI8e78BFBoOHz4shHjWYZG9vb3Q19cXJiYmon///uLatWvFtp1qJpkQQlR+SUZEr7KgoCDs2rVL+lWOiIiIqDqotZfV5eXl4fbt2zAyMlJ7MBgRVb2srCzk5uYiIyOjqlOhCiCEwIMHD2BlZQUtLT5rvCAem4iIqkZJj0219szRrVu3YG1tXdVpEBG9sm7evImGDRtWdRrVCo9NRERV62XHplp75sjIyAjAsw1QsM98IiKqWBkZGbC2tpb2w/Q/PDYREVWNkh6bam1xlH+5glKp5AGIiKgK8LKxwnhsIiKqWi87NvFicCIiIiIiIrA4IiIiIiIiAsDiiIiIiIiICACLIyIiIiIiIgAsjoiIiIiIiACwOCIiIiIiIgLA4oiIiIiIiAgAiyOiqhOkquoMiIiIyo7HM6pFWBwRERERERGBxRFRubKdHlrVKRARERFRKbE4IiIiIiIiAosjIiIiIiIiACyOiIiIiIiIALA4IiIiIiIiAsDiiIiIiIiICACLIyIiIiIiIgAsjoiIiIiIiACwOCIiIiIiIgKgYXE0f/58dOjQAUZGRjAzM8OAAQMQHx+vFvPkyRP4+fmhXr16MDQ0hLe3N1JSUtRikpKS4OXlBQMDA5iZmWHKlCnIyclRi4mMjMTrr78OhUKBpk2bIiQkpHQtJCIiIiIiKgGNiqMjR47Az88PJ0+eRHh4OJ4+fQp3d3c8fPhQipk0aRJ+++03bNu2DUeOHMHt27fxzjvvSNNzc3Ph5eWF7OxsnDhxAj/88ANCQkIwc+ZMKSYxMRFeXl7o2bMnYmNjMXHiRIwaNQr79+8vhyYTEREREREVpqNJcFhYmNrrkJAQmJmZISYmBt27d0d6ejq+//57bNq0Cb169QIArF+/Hvb29jh58iQ6deqEAwcO4NKlSzh48CDMzc3Rtm1bzJ07F9OmTUNQUBDkcjlWr14NOzs7LF68GABgb2+PY8eOYenSpfDw8CinphMREREREf1Pme45Sk9PBwCYmJgAAGJiYvD06VO4ublJMS1atECjRo0QHR0NAIiOjoajoyPMzc2lGA8PD2RkZCAuLk6KKbiM/Jj8ZRQlKysLGRkZagMREREREVFJlbo4ysvLw8SJE9GlSxe0atUKAJCcnAy5XA5jY2O1WHNzcyQnJ0sxBQuj/On5014Uk5GRgcePHxeZz/z586FSqaTB2tq6tE0jIiIiIqJXUKmLIz8/P1y8eBGbN28uz3xKLTAwEOnp6dJw8+bNqk6JiIgqQUk6C3JxcYFMJlMbxo4dqxbDzoKIiKhUxZG/vz/27NmDw4cPo2HDhtJ4CwsLZGdnIy0tTS0+JSUFFhYWUszzvdflv35ZjFKphL6+fpE5KRQKKJVKtYGIiGq/knQWBACjR4/GnTt3pGHBggXSNHYWREREgIbFkRAC/v7+2LlzJw4dOgQ7Ozu16U5OTtDV1UVERIQ0Lj4+HklJSXB2dgYAODs748KFC0hNTZViwsPDoVQq4eDgIMUUXEZ+TP4yiIiI8oWFhWHEiBFo2bIl2rRpg5CQECQlJSEmJkYtzsDAABYWFtJQ8Ee0/M6CNmzYgLZt26J3796YO3cugoODkZ2dDQBqnQXZ29vD398fAwcOxNKlSyu1vUREVHE0Ko78/PywYcMGbNq0CUZGRkhOTkZycrJ0H5BKpYKvry8CAgJw+PBhxMTEYOTIkXB2dkanTp0AAO7u7nBwcMAHH3yAc+fOYf/+/ZgxYwb8/PygUCgAAGPHjsW1a9cwdepU/Pnnn1i5ciW2bt2KSZMmlXPziYiotnm+s6B8GzduRP369dGqVSsEBgbi0aNH0jR2FkRERICGXXmvWrUKwLNrtwtav349RowYAQBYunQptLS04O3tjaysLHh4eGDlypVSrLa2Nvbs2YNx48bB2dkZderUgY+PD+bMmSPF2NnZITQ0FJMmTcLy5cvRsGFDrF27lt14ExHRCxXVWRAADB06FDY2NrCyssL58+cxbdo0xMfHY8eOHQDKp7Ogoi77nj9/PmbPnl2ubSQiooqjUXEkhHhpjJ6eHoKDgxEcHFxsjI2NDfbu3fvC5bi4uODs2bOapEdERK+4/M6Cjh07pjZ+zJgx0v8dHR1haWkJV1dXXL16FU2aNKmwfAIDAxEQECC9zsjIYG+qRETVWJmec0RERFRdFNdZUFE6duwIAEhISADAzoKIiOgZFkdERFSjvayzoKLExsYCACwtLQGwsyAiInqGxREREdVoL+ss6OrVq5g7dy5iYmJw/fp17N69G8OHD0f37t3RunVrAOwsiIiInmFxRERENdqqVauQnp4OFxcXWFpaSsOWLVsAAHK5HAcPHoS7uztatGiByZMnw9vbG7/99pu0jPzOgrS1teHs7Iz3338fw4cPL7KzoPDwcLRp0waLFy9mZ0FERLWMRh0yEBERVTcv6yzI2toaR44ceely2FkQERHxzBERERERERFYHBEREREREQFgcURERERERASAxREREREREREAFkdEREREREQAWBwREREREREBYHFEREREREQEgMURERERERERABZHREREREREAFgcERERERERAWBxREREREREBIDFEREREREREQAWR0RERERERABYHBEREREREQFgcURERERERASAxREREREREREAFkdEREREREQAWBwREREREREBYHFEREREREQEgMUREREREZWR7fRQ2E4Preo0iMqMxRERERERERFYHBEREREREQFgcURERERERASAxREREREREREAFkdEREREREQAWBwREVENN3/+fHTo0AFGRkYwMzPDgAEDEB8frxbz5MkT+Pn5oV69ejA0NIS3tzdSUlLUYpKSkuDl5QUDAwOYmZlhypQpyMnJUYuJjIzE66+/DoVCgaZNmyIkJKSim0dERJWIxREREdVoR44cgZ+fH06ePInw8HA8ffoU7u7uePjwoRQzadIk/Pbbb9i2bRuOHDmC27dv45133pGm5+bmwsvLC9nZ2Thx4gR++OEHhISEYObMmVJMYmIivLy80LNnT8TGxmLixIkYNWoU9u/fX6ntJSKiiqNT1QkQERGVRVhYmNrrkJAQmJmZISYmBt27d0d6ejq+//57bNq0Cb169QIArF+/Hvb29jh58iQ6deqEAwcO4NKlSzh48CDMzc3Rtm1bzJ07F9OmTUNQUBDkcjlWr14NOzs7LF68GABgb2+PY8eOYenSpfDw8Kj0dhMRUfnjmSMiIqpV0tPTAQAmJiYAgJiYGDx9+hRubm5STIsWLdCoUSNER0cDAKKjo+Ho6Ahzc3MpxsPDAxkZGYiLi5NiCi4jPyZ/GUXJyspCRkaG2kBERNUXiyMiIqo18vLyMHHiRHTp0gWtWrUCACQnJ0Mul8PY2Fgt1tzcHMnJyVJMwcIof3r+tBfFZGRk4PHjx0XmM3/+fKhUKmmwtrYucxuJiKjiaFwcRUVFoV+/frCysoJMJsOuXbvUpo8YMQIymUxt8PT0VIu5f/8+hg0bBqVSCWNjY/j6+iIzM1Mt5vz58+jWrRv09PRgbW2NBQsWaN46IiJ6pfj5+eHixYvYvHlzVacCAAgMDER6ero03Lx5s6pTIiKiF9C4OHr48CHatGmD4ODgYmM8PT1x584dafj555/Vpg8bNgxxcXEIDw/Hnj17EBUVhTFjxkjTMzIy4O7uDhsbG8TExGDhwoUICgrCmjVrNE2XiIheEf7+/tizZw8OHz6Mhg0bSuMtLCyQnZ2NtLQ0tfiUlBRYWFhIMc/3Xpf/+mUxSqUS+vr6ReakUCigVCrVBiIiqr407pChd+/e6N279wtjFAqFdDB53uXLlxEWFoYzZ86gffv2AIAVK1agT58+WLRoEaysrLBx40ZkZ2dj3bp1kMvlaNmyJWJjY7FkyRK1IoqIiEgIgfHjx2Pnzp2IjIyEnZ2d2nQnJyfo6uoiIiIC3t7eAID4+HgkJSXB2dkZAODs7Ix58+YhNTUVZmZmAIDw8HAolUo4ODhIMXv37lVbdnh4uLQMIiKq+SrknqPIyEiYmZmhefPmGDduHO7duydNi46OhrGxsVQYAYCbmxu0tLRw6tQpKaZ79+6Qy+VSjIeHB+Lj4/Hvv/8WuU7e9EpE9Gry8/PDhg0bsGnTJhgZGSE5ORnJycnSfUAqlQq+vr4ICAjA4cOHERMTg5EjR8LZ2RmdOnUCALi7u8PBwQEffPABzp07h/3792PGjBnw8/ODQqEAAIwdOxbXrl3D1KlT8eeff2LlypXYunUrJk2aVGVtJyKi8lXuxZGnpyd+/PFHRERE4KuvvsKRI0fQu3dv5ObmAnh2Q2v+r3L5dHR0YGJiotGNsc/jTa9ERK+mVatWIT09HS4uLrC0tJSGLVu2SDFLly5F37594e3tje7du8PCwgI7duyQpmtra2PPnj3Q1taGs7Mz3n//fQwfPhxz5syRYuzs7BAaGorw8HC0adMGixcvxtq1a9mNNxFRLVLuzzkaMmSI9H9HR0e0bt0aTZo0QWRkJFxdXct7dZLAwEAEBARIrzMyMlggERG9AoQQL43R09NDcHDwC++XtbGxKXTZ3PNcXFxw9uxZjXMkIqKaocK78m7cuDHq16+PhIQEAM9uaE1NTVWLycnJwf379zW6MfZ5vOmViIiIiIjKosKLo1u3buHevXuwtLQE8OyG1rS0NMTExEgxhw4dQl5eHjp27CjFREVF4enTp1JMeHg4mjdvjrp161Z0ykRERERE9ArSuDjKzMxEbGwsYmNjAQCJiYmIjY1FUlISMjMzMWXKFJw8eRLXr19HREQE+vfvj6ZNm0rXZNvb28PT0xOjR4/G6dOncfz4cfj7+2PIkCGwsrICAAwdOhRyuRy+vr6Ii4vDli1bsHz5crXL5oiIiIiIiMqTxsXR77//jnbt2qFdu3YAgICAALRr1w4zZ86EtrY2zp8/j7feegvNmjWDr68vnJyccPToUam3HwDYuHEjWrRoAVdXV/Tp0wddu3ZVe4aRSqXCgQMHkJiYCCcnJ0yePBkzZ85kN96vMNvpobCdHlrVaRARERFRLaZxhwwuLi4vvPl1//79L12GiYkJNm3a9MKY1q1b4+jRo5qmR0REREREVCoVfs8RERERERFRTcDiiIiIiIiICCyOqKYJUlV1BkRERERUS7E4IiIiIiIiAosjIiIiIiIiACyOiIiIiIiIALA4IiIiIiIiAsDiiIiIiIiICACLIyIiIiIiIgAsjoiIiIiIiACwOCIiIiIiIgLA4oiIiIiIiAgAiyMiIiIiIiIALI6IiIiIiIgAsDgiIiIiIiICwOKIiIiIiIgIAIsjIiIiIiIiACyOiIiIiIiIAAA6VZ0AEREREdU8ttNDAQDX9ao4EaJyxDNHREREREREYHFEREQ1XFRUFPr16wcrKyvIZDLs2rVLbfqIESMgk8nUBk9PT7WY+/fvY9iwYVAqlTA2Noavry8yMzPVYs6fP49u3bpBT08P1tbWWLBgQUU3jYiIKhmLIyIiqtEePnyINm3aIDg4uNgYT09P3LlzRxp+/vlntenDhg1DXFwcwsPDsWfPHkRFRWHMmDHS9IyMDLi7u8PGxgYxMTFYuHAhgoKCsGbNmgprFxERVT7ec0RERDVa79690bt37xfGKBQKWFhYFDnt8uXLCAsLw5kzZ9C+fXsAwIoVK9CnTx8sWrQIVlZW2LhxI7Kzs7Fu3TrI5XK0bNkSsbGxWLJkiVoRRURENRvPHFVj+Tc6vhKCVFWdARHVYpGRkTAzM0Pz5s0xbtw43Lt3T5oWHR0NY2NjqTACADc3N2hpaeHUqVNSTPfu3SGXy6UYDw8PxMfH499//y12vVlZWcjIyFAbiIio+mJxREREtZqnpyd+/PFHRERE4KuvvsKRI0fQu3dv5ObmAgCSk5NhZmamNo+Ojg5MTEyQnJwsxZibm6vF5L/OjynK/PnzoVKppMHa2ro8m0ZEROWMl9UREVGtNmTIEOn/jo6OaN26NZo0aYLIyEi4urpW6LoDAwMREBAgvc7IyGCBRERUjfHMERERvVIaN26M+vXrIyEhAQBgYWGB1NRUtZicnBzcv39fuk/JwsICKSkpajH5r4u7lwl4dq+TUqlUG4iIqPpicURERK+UW7du4d69e7C0tAQAODs7Iy0tDTExMVLMoUOHkJeXh44dO0oxUVFRePr0qRQTHh6O5s2bo27dupXbACIiqjAsjoiIqEbLzMxEbGwsYmNjAQCJiYmIjY1FUlISMjMzMWXKFJw8eRLXr19HREQE+vfvj6ZNm8LDwwMAYG9vD09PT4wePRqnT5/G8ePH4e/vjyFDhsDKygoAMHToUMjlcvj6+iIuLg5btmzB8uXL1S6ZIyKimo/FERER1Wi///472rVrh3bt2gEAAgIC0K5dO8ycORPa2to4f/483nrrLTRr1gy+vr5wcnLC0aNHoVAopGVs3LgRLVq0gKurK/r06YOuXbuqPcNIpVLhwIEDSExMhJOTEyZPnoyZM2eyG28iolqGHTIQEVGN5uLiAiFEsdP379//0mWYmJhg06ZNL4xp3bo1jh49qnF+RERUc/DMEREREREREVgcERERERER/V97dx8WVbnuD/w7IDMgOIMoMJAImor4grrxRONL2pYtvhwyc5/UuBTbpEc35lZOmp78CaJlR63ULrKTJZzaerQXM7caqZTbMkQjSUIPWxTFioFSAbEcBO7fH26WDG8CzgwDfD/Xta6LWc+z1rqfZ4Z1czNr1gBgcURERERERASAxRERERERERGAFhRHx44dQ0REBHx9faFSqbB3716zdhHBqlWr4OPjAxcXF4SFheH8+fNmfa5du4bIyEhotVq4u7sjOjoaZWVlZn3OnDmD0aNHw9nZGX5+fli/fn3zR0dERERERNREzS6Obt68iSFDhiAxMbHe9vXr12PLli148803kZ6eDldXV4SHh+PWrVtKn8jISGRnZ+Pw4cPYv38/jh07ZnY71NLSUowfPx7+/v7IyMjAhg0bEB8fb3ZbVSIiIiIiIktq9q28J06ciIkTJ9bbJiLYtGkTVq5ciSlTpgAA3n33XXh7e2Pv3r2YMWMGzp07h5SUFJw6dQrDhw8HALz++uuYNGkSNm7cCF9fX+zYsQPl5eXYvn071Go1Bg4ciMzMTLz66qv8TgkiIiIiIrIKi37mKC8vD0ajEWFhYco6nU6H0NBQpKWlAQDS0tLg7u6uFEYAEBYWBgcHB6Snpyt9HnnkEajVaqVPeHg4cnJycP36dUuGTEREREREBMDCXwJrNBoBAN7e3mbrvb29lTaj0QgvLy/zIDp1goeHh1mfXr161dlHdVvXrl3rHNtkMsFkMimPS0tL73M0RERERETUkbSbu9WtW7cOOp1OWfz8/Fo7JCIiIiIiakMsWhzp9XoAQGFhodn6wsJCpU2v16OoqMisvaKiAteuXTPrU98+ah6jthUrVqCkpERZrly5cv8DIiIiIiKiDsOixVGvXr2g1+uRmpqqrCstLUV6ejoMBgMAwGAwoLi4GBkZGUqfzz//HFVVVQgNDVX6HDt2DLdv31b6HD58GIGBgfVeUgcAGo0GWq3WbCEiIiIiImqqZhdHZWVlyMzMRGZmJoA7N2HIzMxEfn4+VCoVFi9ejLVr12Lfvn3IysrC7Nmz4evri8cffxwAEBQUhAkTJmDu3Lk4efIkjh8/joULF2LGjBnw9fUFADz11FNQq9WIjo5GdnY2du/ejc2bNyM2NtZiAyciIiIiIqqp2Tdk+Oabb/Doo48qj6sLlqioKCQnJ2PZsmW4efMm5s2bh+LiYowaNQopKSlwdnZWttmxYwcWLlyIcePGwcHBAdOmTcOWLVuUdp1Oh0OHDiEmJgYhISHo3r07Vq1axdt4ExERERGR1TS7OBo7dixEpMF2lUqFhIQEJCQkNNjHw8MDO3fubPQ4wcHB+PLLL5sbHhERERERUYu0m7vVERERERER3Q8WR0RERERERGBxRERERESNCFh+oLVDILIZFkdERERERERgcURERERERASAxRERERF1NPG61o6AiOwUiyMiIiIiotbCYt2usDgiIiIiIiICiyMiIiIiIiIALI6IiIiIiIgAsDgiIqI27tixY4iIiICvry9UKhX27t1r1i4iWLVqFXx8fODi4oKwsDCcP3/erM+1a9cQGRkJrVYLd3d3REdHo6yszKzPmTNnMHr0aDg7O8PPzw/r16+39tCIiMjGWBwREVGbdvPmTQwZMgSJiYn1tq9fvx5btmzBm2++ifT0dLi6uiI8PBy3bt1S+kRGRiI7OxuHDx/G/v37cezYMcybN09pLy0txfjx4+Hv74+MjAxs2LAB8fHxeOutt6w+PiIisp1OrR0AERHR/Zg4cSImTpxYb5uIYNOmTVi5ciWmTJkCAHj33Xfh7e2NvXv3YsaMGTh37hxSUlJw6tQpDB8+HADw+uuvY9KkSdi4cSN8fX2xY8cOlJeXY/v27VCr1Rg4cCAyMzPx6quvmhVRRETUtvGdIyIiarfy8vJgNBoRFhamrNPpdAgNDUVaWhoAIC0tDe7u7kphBABhYWFwcHBAenq60ueRRx6BWq1W+oSHhyMnJwfXr19v8PgmkwmlpaVmCxER2S8WR0RE1G4ZjUYAgLe3t9l6b29vpc1oNMLLy8usvVOnTvDw8DDrU98+ah6jPuvWrYNOp1MWPz+/+xsQERFZFYsjIiIiK1mxYgVKSkqU5cqVK60dEhERNYLFERERtVt6vR4AUFhYaLa+sLBQadPr9SgqKjJrr6iowLVr18z61LePmseoj0ajgVarNVuIiMh+sTgiIqJ2q1evXtDr9UhNTVXWlZaWIj09HQaDAQBgMBhQXFyMjIwMpc/nn3+OqqoqhIaGKn2OHTuG27dvK30OHz6MwMBAdO3a1UajISIia2NxREREbVpZWRkyMzORmZkJ4M5NGDIzM5Gfnw+VSoXFixdj7dq12LdvH7KysjB79mz4+vri8ccfBwAEBQVhwoQJmDt3Lk6ePInjx49j4cKFmDFjBnx9fQEATz31FNRqNaKjo5GdnY3du3dj8+bNiI2NbaVRExGRNfBW3kRE1KZ98803ePTRR5XH1QVLVFQUkpOTsWzZMty8eRPz5s1DcXExRo0ahZSUFDg7Oyvb7NixAwsXLsS4cePg4OCAadOmYcuWLUq7TqfDoUOHEBMTg5CQEHTv3h2rVq3ibbyJiNoZFkdERNSmjR07FiLSYLtKpUJCQgISEhIa7OPh4YGdO3c2epzg4GB8+eWXLY6TiIjsHy+rIyIiIiIiAosjIiIiIiIiACyOiIiIiIiIALA4IiIiIiIiAsDiiIiIiIiICACLIyIiIiIiIgAsjoiIiIiIiACwOCIiIiIiIgLA4oiIiIiIiAgAiyMiIiIiIiIALI6IiIiIiIgAsDgiIiIiIiICwOKIiIiIiIgIAIsjIiIiIiIiAFYojuLj46FSqcyW/v37K+23bt1CTEwMunXrBjc3N0ybNg2FhYVm+8jPz8fkyZPRuXNneHl5YenSpaioqLB0qERERERERIpO1tjpwIEDceTIkbsH6XT3MEuWLMGBAwfwwQcfQKfTYeHChXjiiSdw/PhxAEBlZSUmT54MvV6Pr7/+GgUFBZg9ezacnJzw0ksvWSNcIiIiIiIi6xRHnTp1gl6vr7O+pKQE77zzDnbu3Inf//73AICkpCQEBQXhxIkTePjhh3Ho0CGcPXsWR44cgbe3N4YOHYo1a9bg+eefR3x8PNRqtTVCJiIiIiKiDs4qnzk6f/48fH190bt3b0RGRiI/Px8AkJGRgdu3byMsLEzp279/f/Ts2RNpaWkAgLS0NAwePBje3t5Kn/DwcJSWliI7O9sa4RIREREREVn+naPQ0FAkJycjMDAQBQUFWL16NUaPHo3vv/8eRqMRarUa7u7uZtt4e3vDaDQCAIxGo1lhVN1e3dYQk8kEk8mkPC4tLbXQiIiIiIiIqCOweHE0ceJE5efg4GCEhobC398f77//PlxcXCx9OMW6deuwevVqq+2fiIiIiIjaN6vfytvd3R39+vVDbm4u9Ho9ysvLUVxcbNansLBQ+YySXq+vc/e66sf1fY6p2ooVK1BSUqIsV65csexAiIiIiIioXbN6cVRWVoYLFy7Ax8cHISEhcHJyQmpqqtKek5OD/Px8GAwGAIDBYEBWVhaKioqUPocPH4ZWq8WAAQMaPI5Go4FWqzVbiIiIiIiImsril9U999xziIiIgL+/P3766SfExcXB0dERM2fOhE6nQ3R0NGJjY+Hh4QGtVotnn30WBoMBDz/8MABg/PjxGDBgAGbNmoX169fDaDRi5cqViImJgUajsXS4REREREREAKxQHP3www+YOXMmrl69Ck9PT4waNQonTpyAp6cnAOC1116Dg4MDpk2bBpPJhPDwcLzxxhvK9o6Ojti/fz8WLFgAg8EAV1dXREVFISEhwdKhEhERERERKSxeHO3atavRdmdnZyQmJiIxMbHBPv7+/jh48KClQyMiIiIiImqQ1T9zRERE1Nri4+OhUqnMlv79+yvtt27dQkxMDLp16wY3NzdMmzatzs2B8vPzMXnyZHTu3BleXl5YunQpKioqbD0UIiKyIou/c0RERGSPBg4ciCNHjiiPO3W6mwKXLFmCAwcO4IMPPoBOp8PChQvxxBNP4Pjx4wCAyspKTJ48GXq9Hl9//TUKCgowe/ZsODk54aWXXrL5WIiIyDpYHBERUYfQqVOner8SoqSkBO+88w527tyJ3//+9wCApKQkBAUF4cSJE3j44Ydx6NAhnD17FkeOHIG3tzeGDh2KNWvW4Pnnn0d8fDzUarWth0NERFbAy+qIiKhDOH/+PHx9fdG7d29ERkYiPz8fAJCRkYHbt28jLCxM6du/f3/07NkTaWlpAIC0tDQMHjwY3t7eSp/w8HCUlpYiOzu7wWOaTCaUlpaaLUREZL9YHBERUbsXGhqK5ORkpKSkYOvWrcjLy8Po0aNx48YNGI1GqNVquLu7m23j7e0No9EIADAajWaFUXV7dVtD1q1bB51Opyx+fn6WHRgREVkUL6sjIqJ2b+LEicrPwcHBCA0Nhb+/P95//324uLhY7bgrVqxAbGys8ri0tJQFEhGRHeM7R0RE1OG4u7ujX79+yM3NhV6vR3l5OYqLi836FBYWKp9R0uv1de5eV/24vs8xVdNoNNBqtWYLERHZLxZHRETU4ZSVleHChQvw8fFBSEgInJyckJqaqrTn5OQgPz8fBoMBAGAwGJCVlYWioiKlz+HDh6HVajFgwACbx09ERNbBy+qIiKjde+655xAREQF/f3/89NNPiIuLg6OjI2bOnAmdTofo6GjExsbCw8MDWq0Wzz77LAwGAx5++GEAwPjx4zFgwADMmjUL69evh9FoxMqVKxETEwONRtPKoyMiIkthcURERO3eDz/8gJkzZ+Lq1avw9PTEqFGjcOLECXh6egIAXnvtNTg4OGDatGkwmUwIDw/HG2+8oWzv6OiI/fv3Y8GCBTAYDHB1dUVUVBQSEhJaa0hERGQFLI6IiKjd27VrV6Ptzs7OSExMRGJiYoN9/P39cfDgQUuHRkREdoSfOSIiIiIiIgKLIyIiIiIiIgAsjsiKApYfaO0QiIiIiIiajMURUUvF61o7grvsKRYiIiKiNorFEREREREREVgcERERERERAWBxRGRbzbj8LWD5AX5ui4iIiMiGWBwRERERERGBxREREREREREAFkdERERETcbLnYnaNxZHREREREREYHFERERE1GHwnS+ixrE4IiIiIiIiAosjIiIiIiIiACyOiIiIiIiIALA4IjvA65+JiIiIyB6wOCIiIiIiIgKLo/sWsPwA3/loqXhda0dAREQdQHvK0+1pLET2iMURERERERERWBwRERFRW8MrD4jISlgcERERUfvHgoraGr5mWwWLIyIiIiKi9oAF1X1jcURtHj+cSkRERESWwOKIGsSiA3f+A2Pr/8I04Zh8boiIiIgsj8URERERERER7Lw4SkxMREBAAJydnREaGoqTJ0+2dkh0v+zkWtimvPPSod6daY13yIjaKOYmIrK5+83TzPNNZrfF0e7duxEbG4u4uDh8++23GDJkCMLDw1FUVNTaodn1F79aKy57HrNFNPOEYdO54MmMyG7Yc25qF2r/AXe/lxhb6/xpg/OyLfJMi4/R1D+0mb+oDbLb4ujVV1/F3Llz8fTTT2PAgAF488030blzZ2zfvr21Q2t3LHkCvt992UUBxv/OEFEDmJss5D7OkY3miX+ef1v7H3q1j28Xua0l2lgua7PzfL8s+Ty1sefcGjq1dgD1KS8vR0ZGBlasWKGsc3BwQFhYGNLS0urdxmQywWQyKY9LSkoAAKWlpRaPr8r0q7Lvmj831aC4zwAA368Or7eten2V6VdlvzXXN3WbhvrUPn5D29RcX3Octbdv6PhVpl9RukJ7p8+td+5s4ywYtOQD5Wf8cw5LVTV+XqEFVvxwJ4h1Pf65rzvbV/erc8x/bjMo7jN87xytHLP6Z7P9rfih7tw619ivs9zdr+rOz3djjr67fc1Yaq+vtU3N8Zsdp9b2AADT3ePXHHOd+GvOk6lWn3rG3OjP/zwmSksb376m2vuquU1DGttXU45JbUL175aItHIklmXvuanVNHYuqOec09D5r+b5t3aeqHPOr50zUH3Or//8WfecXev4qJmnapyzG8pzNc/L9aj9t0Gdc/Y/NSs3N5S/av9tUHOe6/m7oU6errGvOmN2biA315On6v17yNT4PLVYAzmnoXmuuc2gW+80+PdUUzQ25/Uesym5rKF5qrm+Zp6uve/a/Rrq09D2De2r5jy3gzzd5NwkdujHH38UAPL111+brV+6dKk89NBD9W4TFxcnALhw4cKFi50sV65csUXKsBnmJi5cuHBp+8u9cpNdvnPUEitWrEBsbKzyuKqqCteuXUO3bt2gUqlaMTLLKi0thZ+fH65cuQKtVtva4dhURx17Rx030HHH3tbHLSK4ceMGfH19WzuUVteeclNbf11aCufhLs7FHZyHO+x9Hpqam+yyOOrevTscHR1RWFhotr6wsBB6vb7ebTQaDTQajdk6d3d3a4XY6rRarV2+8Gyho469o44b6Lhjb8vj1ul0rR2CxTE33dGWX5eWxHm4i3NxB+fhDnueh6bkJru8IYNarUZISAhSU1OVdVVVVUhNTYXBYGjFyIiIqKNibiIiav/s8p0jAIiNjUVUVBSGDx+Ohx56CJs2bcLNmzfx9NNPt3ZoRETUQTE3ERG1b3ZbHE2fPh0///wzVq1aBaPRiKFDhyIlJQXe3t6tHVqr0mg0iIuLq3OZRkfQUcfeUccNdNyxd9RxtwUdOTfxdXkH5+EuzsUdnIc72ss8qETa2b1WiYiIiIiIWsAuP3NERERERERkayyOiIiIiIiIwOKIiIiIiIgIAIsjIiIiIiIiACyO2oRr164hMjISWq0W7u7uiI6ORllZWaP9n332WQQGBsLFxQU9e/bEokWLUFJSYsOoWyYxMREBAQFwdnZGaGgoTp482Wj/Dz74AP3794ezszMGDx6MgwcP2ihSy2rOuLdt24bRo0eja9eu6Nq1K8LCwu45T/asuc95tV27dkGlUuHxxx+3boBW0txxFxcXIyYmBj4+PtBoNOjXr1+bfb1T2/Hiiy9ixIgR6Ny5c5O/vFZEsGrVKvj4+MDFxQVhYWE4f/68dQO1submYQAYO3YsVCqV2TJ//nwbRWw5HTUv19aceUhOTq7z3Ds7O9swWus4duwYIiIi4OvrC5VKhb17995zm6NHj+J3v/sdNBoN+vTpg+TkZKvHed+E7N6ECRNkyJAhcuLECfnyyy+lT58+MnPmzAb7Z2VlyRNPPCH79u2T3NxcSU1Nlb59+8q0adNsGHXz7dq1S9RqtWzfvl2ys7Nl7ty54u7uLoWFhfX2P378uDg6Osr69evl7NmzsnLlSnFycpKsrCwbR35/mjvup556ShITE+X06dNy7tw5mTNnjuh0Ovnhhx9sHPn9a+7Yq+Xl5ckDDzwgo0ePlilTptgmWAtq7rhNJpMMHz5cJk2aJF999ZXk5eXJ0aNHJTMz08aRU0ezatUqefXVVyU2NlZ0Ol2Ttnn55ZdFp9PJ3r175bvvvpPHHntMevXqJb/99pt1g7Wi5uZhEZExY8bI3LlzpaCgQFlKSkpsFLFldNS8XFtz5yEpKUm0Wq3Zc280Gm0cteUdPHhQXnjhBdmzZ48AkI8//rjR/hcvXpTOnTtLbGysnD17Vl5//XVxdHSUlJQU2wTcQiyO7NzZs2cFgJw6dUpZ9+mnn4pKpZIff/yxyft5//33Ra1Wy+3bt60RpkU89NBDEhMTozyurKwUX19fWbduXb39n3zySZk8ebLZutDQUPn3f/93q8Zpac0dd20VFRXSpUsX+Z//+R9rhWg1LRl7RUWFjBgxQt5++22Jiopqk8VRc8e9detW6d27t5SXl9sqRCIzSUlJTSqOqqqqRK/Xy4YNG5R1xcXFotFo5H//93+tGKH1tDQPjxkzRv7yl7/YIELr6ah5ubbmzkNTf1/asqYUR8uWLZOBAwearZs+fbqEh4dbMbL7x8vq7FxaWhrc3d0xfPhwZV1YWBgcHByQnp7e5P2UlJRAq9WiUyf7/N7f8vJyZGRkICwsTFnn4OCAsLAwpKWl1btNWlqaWX8ACA8Pb7C/PWrJuGv79ddfcfv2bXh4eFgrTKto6dgTEhLg5eWF6OhoW4RpcS0Z9759+2AwGBATEwNvb28MGjQIL730EiorK20VNlGT5OXlwWg0mr2+dTodQkND29S5uab7ycM7duxA9+7dMWjQIKxYsQK//vqrtcO1mI6al2traa4qKyuDv78//Pz8MGXKFGRnZ9siXLvSVl8P9vmXMimMRiO8vLzM1nXq1AkeHh4wGo1N2scvv/yCNWvWYN68edYI0SJ++eUXVFZW1vmWeW9vb/zf//1fvdsYjcZ6+zd1XuxBS8Zd2/PPPw9fX986JyB715Kxf/XVV3jnnXeQmZlpgwitoyXjvnjxIj7//HNERkbi4MGDyM3NxZ///Gfcvn0bcXFxtgibqEmqz79t/dxcU0vz8FNPPQV/f3/4+vrizJkzeP7555GTk4M9e/ZYO2SL6Kh5ubaWzENgYCC2b9+O4OBglJSUYOPGjRgxYgSys7PRo0cPW4RtFxp6PZSWluK3336Di4tLK0XWOL5z1EqWL19e58N6tZem/nHcmNLSUkyePBkDBgxAfHz8/QdOduXll1/Grl278PHHH7eLD3s25saNG5g1axa2bduG7t27t3Y4NlVVVQUvLy+89dZbCAkJwfTp0/HCCy/gzTffbO3QqA2yVf6xd9aeh3nz5iE8PByDBw9GZGQk3n33XXz88ce4cOGCBUdB9shgMGD27NkYOnQoxowZgz179sDT0xP//d//3dqhURPwnaNW8h//8R+YM2dOo3169+4NvV6PoqIis/UVFRW4du0a9Hp9o9vfuHEDEyZMQJcuXfDxxx/DycnpfsO2mu7du8PR0RGFhYVm6wsLCxscp16vb1Z/e9SScVfbuHEjXn75ZRw5cgTBwcHWDNMqmjv2Cxcu4NKlS4iIiFDWVVVVAbjzX9ycnBw8+OCD1g3aAlrynPv4+MDJyQmOjo7KuqCgIBiNRpSXl0OtVls1Zmpfmpp/WqL6NVxYWAgfHx9lfWFhIYYOHdqifVqLLfJwTaGhoQCA3Nzcdnuuag95ubb7ydPVnJycMGzYMOTm5lojRLvV0OtBq9Xa7btGAN85ajWenp7o379/o4tarYbBYEBxcTEyMjKUbT///HNUVVUpJ9r6lJaWYvz48VCr1di3b5/dv6ugVqsREhKC1NRUZV1VVRVSU1NhMBjq3cZgMJj1B4DDhw832N8etWTcALB+/XqsWbMGKSkpZtfBtyXNHXv//v2RlZWFzMxMZXnsscfw6KOPIjMzE35+frYMv8Va8pyPHDkSubm5SjEIAP/4xz/g4+PDwoiaran5pyV69eoFvV5v9vouLS1Fenq63Z2brZ2Ha6u+HLhm0WjPOmperq2lebqmyspKZGVltZnn3lLa7Ouhte8IQfc2YcIEGTZsmKSnp8tXX30lffv2NbuF6A8//CCBgYGSnp4uIiIlJSUSGhoqgwcPltzcXLNbSVZUVLTWMO5p165dotFoJDk5Wc6ePSvz5s0Td3d35faXs2bNkuXLlyv9jx8/Lp06dZKNGzfKuXPnJC4urk3eMrS543755ZdFrVbLhx9+aPbc3rhxo7WG0GLNHXttbfVudc0dd35+vnTp0kUWLlwoOTk5sn//fvHy8pK1a9e21hCog7h8+bKcPn1aVq9eLW5ubnL69Gk5ffq02fkmMDBQ9uzZozx++eWXxd3dXT755BM5c+aMTJkypV3cyrs5eTg3N1cSEhLkm2++kby8PPnkk0+kd+/e8sgjj7TWEFqko+bl2po7D6tXr5bPPvtMLly4IBkZGTJjxgxxdnaW7Ozs1hqCRdy4cUM5BwCQV199VU6fPi2XL18WEZHly5fLrFmzlP7Vt/JeunSpnDt3ThITE3krb7KMq1evysyZM8XNzU20Wq08/fTTZokpLy9PAMgXX3whIiJffPGFAKh3ycvLa51BNNHrr78uPXv2FLVaLQ899JCcOHFCaRszZoxERUWZ9X///felX79+olarZeDAgXLgwAEbR2wZzRm3v79/vc9tXFyc7QO3gOY+5zW11eJIpPnj/vrrryU0NFQ0Go307t1bXnzxRbv+Zwe1D1FRUfWeb6rzjcidW/omJSUpj6uqquT//b//J97e3qLRaGTcuHGSk5Nj++AtqLl5OD8/Xx555BHx8PAQjUYjffr0kaVLl7a57zkS6bh5ubbmzMPixYuVvt7e3jJp0iT59ttvWyFqy2ro78vqsUdFRcmYMWPqbDN06FBRq9XSu3dvs3OFvVKJiNjsbSoiIiIiIiI7xc8cERERERERgcURERERERERABZHREREREREAFgcERERERERAWBxREREREREBIDFEREREREREQAWR0RERERERABYHJEdGDt2LBYvXmyz4yUnJ8Pd3d1mxyMiovaB+Yqo/WNxRDYxZ84cqFSqOktubi727NmDNWvWKH0DAgKwadMms+1tnSBqxqjVavEv//Iv+OSTT5q1j0uXLkGlUiEzM9M6QaL+uWrM0aNHoVKpUFxcbLWYLM3Wf4wQUcfGfGUdAQEBdea0R48eFtm3SqXC3r17LbIvAFi0aBFCQkKg0WgwdOhQi+2X2gYWR2QzEyZMQEFBgdnSq1cveHh4oEuXLq0dXh1JSUkoKCjAN998g5EjR+KPf/wjsrKyWiWW27dvt8pxGyIiqKioaO0wiIisgvmq5RrLVwkJCWZzevr0aRtGdm81Y//Tn/6E6dOnt2I01FpYHJHNaDQa6PV6s8XR0dHsnYGxY8fi8uXLWLJkifKfpaNHj+Lpp59GSUmJsi4+Ph4AYDKZ8Nxzz+GBBx6Aq6srQkNDcfToUbPjJicno2fPnujcuTOmTp2Kq1evNiled3d36PV69OvXD2vWrEFFRQW++OILpT0lJQWjRo2Cu7s7unXrhn/913/FhQsXlPZevXoBAIYNGwaVSoWxY8cqbW+//TaCgoLg7OyM/v3744033lDaqv+Dt3v3bowZMwbOzs7YsWNHk2JWqVR4++23MXXqVHTu3Bl9+/bFvn37lP0++uijAICuXbtCpVJhzpw5AICqqiqsW7cOvXr1gouLC4YMGYIPP/xQ2W/1O06ffvqp8t+0r776ClVVVVi/fj369OkDjUaDnj174sUXX1S2u3LlCp588km4u7vDw8MDU6ZMwaVLl5T2OXPm4PHHH8fq1avh6ekJrVaL+fPno7y8XGn/+9//js2bNyvP/aVLl3D9+nVERkbC09MTLi4u6Nu3L5KSkpo0R0RE98J8NVZps2S+6tKli9mcenp6orKyEtHR0Ur+CQwMxObNm+tsu337dgwcOBAajQY+Pj5YuHAhgDvvSAHA1KlToVKplMcAsHXrVjz44INQq9UIDAzEe++9Z7ZPlUqFrVu34rHHHoOrq6uSv7Zs2YKYmBj07t273nFcvnwZERER6Nq1K1xdXTFw4EAcPHiwwXFTGyNENhAVFSVTpkypt23MmDHyl7/8RURErl69Kj169JCEhAQpKCiQgoICMZlMsmnTJtFqtcq6GzduiIjIM888IyNGjJBjx45Jbm6ubNiwQTQajfzjH/8QEZETJ06Ig4OD/Nd//Zfk5OTI5s2bxd3dXXQ6XaPxApCPP/5YRERu374tr732mgCQrVu3Kn0+/PBD+eijj+T8+fNy+vRpiYiIkMGDB0tlZaWIiJw8eVIAyJEjR6SgoECuXr0qIiJ//etfxcfHRz766CO5ePGifPTRR+Lh4SHJyckiIpKXlycAJCAgQOnz008/1Runv7+/vPbaa2Zx9+jRQ3bu3Cnnz5+XRYsWiZubm1y9elUqKirko48+EgCSk5MjBQUFUlxcLCIia9eulf79+0tKSopcuHBBkpKSRKPRyNGjR0VE5IsvvhAAEhwcLIcOHZLc3Fy5evWqLFu2TLp27SrJycmSm5srX375pWzbtk1ERMrLyyUoKEj+9Kc/yZkzZ+Ts2bPy1FNPSWBgoJhMJuV14ebmJtOnT5fvv/9e9u/fL56envKf//mfIiJSXFwsBoNB5s6dqzz3FRUVEhMTI0OHDpVTp05JXl6eHD58WPbt29foc0pE1BTMV7bJV9XKy8tl1apVcurUKbl48aL89a9/lc6dO8vu3buVPm+88YY4OzvLpk2bJCcnR06ePKnsq6ioSABIUlKSFBQUSFFRkYiI7NmzR5ycnCQxMVFycnLklVdeEUdHR/n888/N5s7Ly0u2b98uFy5ckMuXL5vFFhcXJ0OGDKkT8+TJk+UPf/iDnDlzRi5cuCB/+9vf5O9//3sjzxK1JSyOyCaioqLE0dFRXF1dleWPf/yjiJgnG5H6T6BJSUl1EsTly5fF0dFRfvzxR7P148aNkxUrVoiIyMyZM2XSpElm7dOnT29SsnF2dhZXV1dxcHBQTv7VCaM+P//8swCQrKwsEbmbNE6fPm3W78EHH5SdO3earVuzZo0YDAaz7TZt2tRojCL1F0crV65UHpeVlQkA+fTTT0XkbpFz/fp1pc+tW7ekc+fO8vXXX5vtOzo6WmbOnGm23d69e5X20tJS0Wg0SjFU23vvvSeBgYFSVVWlrDOZTOLi4iKfffaZiNx5XXh4eMjNmzeVPlu3bhU3Nzcladd+fYiIREREyNNPP32v6SEiajbmq7ssna/UarXZvG7evLnevjExMTJt2jTlsa+vr7zwwgsN7rtmgVhtxIgRMnfuXLN1//Zv/2Y2xwBk8eLFDe63oeJo8ODBEh8f3+B21LZ1ssnbU0QAHn30UWzdulV57Orqel/7y8rKQmVlJfr162e23mQyoVu3bgCAc+fOYerUqWbtBoMBKSkp99z/a6+9hrCwMFy8eBFLlizBli1b4OHhobSfP38eq1atQnp6On755RdUVVUBAPLz8zFo0KB693nz5k1cuHAB0dHRmDt3rrK+oqICOp3OrO/w4cPvGWN9goODlZ9dXV2h1WpRVFTUYP/c3Fz8+uuv+MMf/mC2vry8HMOGDWswpnPnzsFkMmHcuHH17ve7775Dbm5unevzb926ZXY5x5AhQ9C5c2flscFgQFlZGa5cuQJ/f/96971gwQJMmzYN3377LcaPH4/HH38cI0aMaHCMRETNwXxlnXy1dOlS5XJuAOjevTsAIDExEdu3b0d+fj5+++03lJeXKzdCKCoqwk8//dRgrmnIuXPnMG/ePLN1I0eOrHPJXkty7aJFi7BgwQIcOnQIYWFhmDZtmlnupbaNxRHZjKurK/r06WOx/ZWVlcHR0REZGRlwdHQ0a3Nzc7vv/ev1evTp0wd9+vRBUlISJk2ahLNnz8LLywsAEBERAX9/f2zbtg2+vr6oqqrCoEGDlM/LNBQzAGzbtg2hoaFmbbXH0NJk7OTkZPZYpVIpibCxmA4cOIAHHnjArE2j0TQYk4uLS6NxlJWVISQkpN7rzz09PRvd9l4mTpyIy5cv4+DBgzh8+DDGjRuHmJgYbNy48b72S0QEMF9VxwxYNl917969zrzu2rULzz33HF555RUYDAZ06dIFGzZsQHp6OoB755r71ZJc+8wzzyA8PBwHDhzAoUOHsG7dOrzyyit49tlnrRAh2RqLI7I7arUalZWV91w3bNgwVFZWoqioCKNHj653X0FBQcoJttqJEyeaHdNDDz2EkJAQvPjii9i8eTOuXr2KnJwcbNu2TTn2V199VSdmAGZxe3t7w9fXFxcvXkRkZGSz47hf9cU0YMAAaDQa5OfnY8yYMU3eV9++feHi4oLU1FQ888wzddp/97vfYffu3fDy8oJWq21wP9999x1+++03JQGeOHECbm5u8PPzU2Ku/dwDdwqsqKgoREVFYfTo0Vi6dCmLIyKyKear+3f8+HGMGDECf/7zn5V1Na8u6NKlCwICApCamqrcVKg2JyenOnMeFBSE48ePIyoqyuxYAwYMsEjcfn5+mD9/PubPn48VK1Zg27ZtLI7aCRZHZHcCAgJw7NgxzJgxAxqNBt27d0dAQADKysqQmpqqXIbVr18/REZGYvbs2XjllVcwbNgw/Pzzz0hNTUVwcDAmT56MRYsWYeTIkdi4cSOmTJmCzz77rEmXKNRn8eLFmDp1KpYtWwYfHx9069YNb731Fnx8fJCfn4/ly5eb9ffy8oKLiwtSUlLQo0cPODs7Q6fTYfXq1Vi0aBF0Oh0mTJgAk8mEb775BtevX0dsbKwlprBB/v7+UKlU2L9/PyZNmgQXFxd06dIFzz33HJYsWYKqqiqMGjUKJSUlOH78OLRarVliqcnZ2RnPP/88li1bBrVajZEjR+Lnn39GdnY2oqOjERkZiQ0bNmDKlClISEhAjx49cPnyZezZswfLli1Tvt+ivLwc0dHRWLlyJS5duoS4uDgsXLgQDg53bqYZEBCA9PR0XLp0CW5ubvDw8EB8fDxCQkIwcOBAmEwm7N+/H0FBQVadOyKi2piv7l/fvn3x7rvv4rPPPkOvXr3w3nvv4dSpU8od9AAgPj4e8+fPh5eXFyZOnIgbN27g+PHjSjFSXTyNHDkSGo0GXbt2xdKlS/Hkk09i2LBhCAsLw9/+9jfs2bMHR44cuWdMubm5KCsrg9FoxG+//aZ8/9OAAQOgVquxePFiTJw4Ef369cP169fxxRdfMAe1J639oSfqGJp69x8RkbS0NAkODhaNRiM1X6Lz58+Xbt26CQCJi4sTkbt3uQkICBAnJyfx8fGRqVOnypkzZ5Tt3nnnHenRo4e4uLhIRESEbNy4sVl3/6lWVVUl/fv3lwULFoiIyOHDhyUoKEg0Go0EBwfL0aNH62y3bds28fPzEwcHBxkzZoyyfseOHTJ06FBRq9XStWtXeeSRR2TPnj0i0vAHY+tT3w0Zaset0+kkKSlJeZyQkCB6vV5UKpVERUUpY9u0aZMEBgaKk5OTeHp6Snh4uHL3nfpu5CAiUllZKWvXrhV/f39xcnKSnj17yksvvaS0FxQUyOzZs6V79+6i0Wikd+/eMnfuXCkpKRGRu6+LVatWSbdu3cTNzU3mzp0rt27dUvaRk5MjDz/8sLi4uAgAycvLkzVr1khQUJC4uLiIh4eHTJkyRS5evHjP+SIiuhfmK9vkq2q3bt2SOXPmiE6nE3d3d1mwYIEsX768zo0Q3nzzTSVH+fj4yLPPPqu07du3T/r06SOdOnUSf39/Zf0bb7whvXv3FicnJ+nXr5+8++6795w7kTvPM4A6S15enoiILFy4UB588EHRaDTi6ekps2bNkl9++eWec0Btg0pExMb1GBERgDvfY1RcXGzRbzYnIiIiail+CSwRERERERFYHBEREREREQEAeFkdERERERER+M4RERERERERABZHREREREREAFgcERERERERAWBxREREREREBIDFEREREREREQAWR0RERERERABYHBEREREREQFgcURERERERASAxREREREREREA4P8D/suT+DRJZm0AAAAASUVORK5CYII=", + "image/png": "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", "text/plain": [ "
" ] @@ -847,17 +892,21 @@ "source": [ "fig, ax = plt.subplots(2, 2, figsize=(10,6))\n", "\n", - "ax[0][0].hist([all_spec_fitNoteParams[0][\"internalNoteIntercept\"], all_unif_fitNoteParams[0][\"internalNoteIntercept\"]], bins=100)\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\"], all_unif_fitNoteParams[0][\"internalNoteFactor1\"]], bins=100, label=[\"Spectral Init\", \"Uniform Init\"])\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\"], all_unif_fitRaterParams[0][\"internalRaterIntercept\"]], bins=100)\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\"], all_unif_fitRaterParams[0][\"internalRaterFactor1\"]], bins=100)\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", @@ -866,20 +915,22 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "C:\\Users\\iijof\\AppData\\Local\\Temp\\ipykernel_19676\\1387034380.py:17: UserWarning: FigureCanvasAgg is non-interactive, and thus cannot be shown\n", + "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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", + "image/png": "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", "text/plain": [ "
" ] @@ -891,17 +942,21 @@ "source": [ "fig, ax = plt.subplots(2, 2, figsize=(10,6))\n", "\n", - "ax[0][0].hist([all_spec_fitNoteParams_dense[0][\"internalNoteIntercept\"], all_unif_fitNoteParams_dense[0][\"internalNoteIntercept\"]], bins=100)\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\"], all_unif_fitNoteParams_dense[0][\"internalNoteFactor1\"]], bins=100, label=[\"Spectral Init\", \"Uniform Init\"])\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\"], all_unif_fitRaterParams_dense[0][\"internalRaterIntercept\"]], bins=100)\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\"], all_unif_fitRaterParams_dense[0][\"internalRaterFactor1\"]], bins=100)\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", From 672d52005baf281d342961c6c87d7e3160259421 Mon Sep 17 00:00:00 2001 From: IanJoffe Date: Sun, 15 Sep 2024 21:22:44 -0700 Subject: [PATCH 6/7] finalizing tests notebook and fixing global intercept bug --- .../matrix_factorization.py | 4 +- sourcecode/test_mf.ipynb | 589 +----------------- 2 files changed, 20 insertions(+), 573 deletions(-) diff --git a/sourcecode/scoring/matrix_factorization/matrix_factorization.py b/sourcecode/scoring/matrix_factorization/matrix_factorization.py index 99285b5f4..5b3c67736 100644 --- a/sourcecode/scoring/matrix_factorization/matrix_factorization.py +++ b/sourcecode/scoring/matrix_factorization/matrix_factorization.py @@ -242,9 +242,7 @@ def _initialize_parameters( if globalInterceptInit is not None: if self._log: logger.info("initialized global intercept") - self.mf_model.global_intercept.data = 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]: """ diff --git a/sourcecode/test_mf.ipynb b/sourcecode/test_mf.ipynb index 2f91527e6..7564629d2 100644 --- a/sourcecode/test_mf.ipynb +++ b/sourcecode/test_mf.ipynb @@ -11,7 +11,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "I noticed that previously, 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. " + "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. " ] }, { @@ -48,216 +48,9 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n" - ] - } - ], + "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", @@ -273,56 +66,9 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n" - ] - } - ], + "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", @@ -338,216 +84,9 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n" - ] - } - ], + "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", @@ -568,56 +107,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:585: RuntimeWarning: Mean of empty slice\n", - " mean_matrix = 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=1), nan=np.nanmean(data_matrix))[:,np.newaxis] \\\n", - "c:\\Users\\iijof\\Desktop\\communitynotes\\sourcecode\\scoring\\matrix_factorization\\matrix_factorization.py:586: RuntimeWarning: Mean of empty slice\n", - " + 1/2*np.nan_to_num(np.nanmean(data_matrix, axis=0), nan=np.nanmean(data_matrix)) \\\n" - ] - } - ], + "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", @@ -642,17 +134,17 @@ "source": [ "## Results\n", "\n", - "I found the results surprsing! 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 the uniform initialization gave better training loss, but the spectal initialization gave far better validation 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!\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`.\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", - "The uniform initialization also does much better in the metric just titled loss, which looks just the loss of Adam's last batch. I expect the other loss metrics to be more informative so I'm not too worried about it, but I figured I'd include it since the original code chose to return it so you might find it relevant for something. \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", - "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) pair) which I found intuative 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 was in the sample. This led to a much denser (but still very sparse) ratings matrix. \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", - "As a sanity check, I also took a look at the values of parameters returned by both initializations. They definitely are a little bit different, but neither looks more right or wrong than the other. This is also something interesting to continue to ponder. \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", - "Unfortunately, SVD is expenseive to compute, and also 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 sure, but it's possible there exist algorithms to get the top of the SVD without ever actually forming the raters-by-notes matrix." + "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 :). " ] }, { @@ -742,51 +234,6 @@ "plt.show()" ] }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "C:\\Users\\iijof\\AppData\\Local\\Temp\\ipykernel_5220\\650318728.py:18: 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(1,3, figsize=(12,4))\n", - "\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", - "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", - "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", - "fig.show()" - ] - }, { "cell_type": "code", "execution_count": 11, @@ -967,7 +414,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Additionally, in all settings, the spectral initialization always gives a global intercept near $0.6$, very close the the mean rating, which is what I set empty cells in the to-be-decomposed matrix to. The uniform initialization, on the other hand, almost always gives a global intercept near $0.08$. Since that code initializes the global intercept to 0, I don't know where this comes from. " + "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. " ] }, { @@ -976,7 +425,7 @@ "source": [ "## Iterative Spectral Initialization\n", "\n", - "I also had the 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, as above, 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. 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", + "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. " ] From 621e08dfd615642bc1c4c7aa2a8486f67299f93e Mon Sep 17 00:00:00 2001 From: IanJoffe Date: Thu, 2 Jan 2025 23:05:11 -0600 Subject: [PATCH 7/7] sparse svd --- .../matrix_factorization.py | 89 +++++++++++++------ sourcecode/test_mf.ipynb | 22 ++++- 2 files changed, 85 insertions(+), 26 deletions(-) diff --git a/sourcecode/scoring/matrix_factorization/matrix_factorization.py b/sourcecode/scoring/matrix_factorization/matrix_factorization.py index 5b3c67736..260d54d0a 100644 --- a/sourcecode/scoring/matrix_factorization/matrix_factorization.py +++ b/sourcecode/scoring/matrix_factorization/matrix_factorization.py @@ -9,6 +9,7 @@ import numpy as np import pandas as pd import torch +from scipy.sparse import csc_matrix from scipy.sparse.linalg import svds @@ -160,25 +161,67 @@ def get_note_and_rater_id_maps( return noteIdMap, raterIdMap, ratingFeaturesAndLabels - def _form_data_df(self): + def _form_data_matrix(self, saveMemory=False): """ - Returns: pd.DataFrame, a (number of notes) x (number of raters) df filled with ratings data, - with validation data nan'ed out. + 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 - This takes up a lot of memeory - I avoid ever having multiple of them around by deleting the reference + 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. + not having to call this multiple times. Currently _form_data_df is only called when a Spectral Initialization occurs. """ - 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 - return data_df + 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, @@ -516,6 +559,7 @@ def run_mf( 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, @@ -534,6 +578,7 @@ def run_mf( 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 @@ -577,30 +622,24 @@ def run_mf( if useSpectralInit: self._create_train_validate_sets(validatePercent) - data_df = self._form_data_df() - data_matrix = data_df.values - # might be worth trying to tune the weights from 1/2-1/2, I didn't see a huge different in limited experiments but don't have the compute to be definative - 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) # warning can be ignored, I deal with it by wrapping with a nan_to_num - filled_matrix = np.where(np.isnan(data_matrix), mean_matrix, data_matrix) + data_matrix, data_index, data_cols, subtracted_intercept = self._form_data_matrix(saveMemory=saveMemorySVD) - U, S, Vt = svds(filled_matrix, k=self._numFactors) + 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_df.index, + 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_df.columns, + c.raterParticipantIdKey: data_cols, c.rater_factor_key(1): user_factor_init_vals, c.internalRaterInterceptKey: np.zeros(len(user_factor_init_vals)) }) - globalInterceptInit = np.nanmean(data_matrix) - del data_df, data_matrix # save lots of memory + 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) diff --git a/sourcecode/test_mf.ipynb b/sourcecode/test_mf.ipynb index 7564629d2..131c0c343 100644 --- a/sourcecode/test_mf.ipynb +++ b/sourcecode/test_mf.ipynb @@ -90,7 +90,7 @@ "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): # change back to 50 later\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", @@ -429,6 +429,26 @@ "\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": {