diff --git a/BirdSTEM/model/AdaSTEM.py b/BirdSTEM/model/AdaSTEM.py index 3e15a61..e756bab 100644 --- a/BirdSTEM/model/AdaSTEM.py +++ b/BirdSTEM/model/AdaSTEM.py @@ -50,16 +50,13 @@ import re import statsmodels.api as sm - -from sklearn.ensemble import RandomForestRegressor,RandomForestClassifier +from sklearn.base import BaseEstimator from sklearn.model_selection import train_test_split from sklearn.metrics import r2_score,mean_squared_error,mean_tweedie_deviance,\ mean_absolute_error,mean_absolute_percentage_error from sklearn.metrics import roc_auc_score, precision_score, accuracy_score, f1_score,recall_score from scipy.stats import spearmanr -from xgboost import XGBRegressor,XGBClassifier,XGBRFClassifier,XGBRFRegressor from sklearn.utils import class_weight -import xgboost as xgb from sklearn.inspection import partial_dependence ###### @@ -70,7 +67,7 @@ -class AdaSTEM: +class AdaSTEM(BaseEstimator): ''' attributes: @@ -101,8 +98,8 @@ def __init__(self,base_model, task='hurdle', ensemble_fold=1, min_ensemble_require = 1, - grid_len_long_upper_threshold=25, - grid_len_long_lower_threshold=5, + grid_len_lon_upper_threshold=25, + grid_len_lon_lower_threshold=5, grid_len_lat_upper_threshold=25, grid_len_lat_lower_threshold=5, points_lower_threshold=50, @@ -110,6 +107,7 @@ def __init__(self,base_model, temporal_end=366, temporal_step=20, temporal_bin_interval = 50, + temporal_bin_start_jitter = 'random', stixel_training_size_threshold = 50, save_gridding_plot=True, save_tmp = True, @@ -132,8 +130,8 @@ def __init__(self,base_model, self.ensemble_fold = ensemble_fold self.min_ensemble_require = min_ensemble_require - self.grid_len_long_upper_threshold=grid_len_long_upper_threshold - self.grid_len_long_lower_threshold=grid_len_long_lower_threshold + self.grid_len_lon_upper_threshold=grid_len_lon_upper_threshold + self.grid_len_lon_lower_threshold=grid_len_lon_lower_threshold self.grid_len_lat_upper_threshold=grid_len_lat_upper_threshold self.grid_len_lat_lower_threshold=grid_len_lat_lower_threshold self.points_lower_threshold=points_lower_threshold @@ -141,20 +139,61 @@ def __init__(self,base_model, self.temporal_end = temporal_end self.temporal_step = temporal_step self.temporal_bin_interval = temporal_bin_interval + + if (not type(temporal_bin_start_jitter) in [str, float, int]): + raise AttributeError(f'Input temporal_bin_start_jitter should be \'random\', float or int, got {type(temporal_bin_start_jitter)}') + if type(temporal_bin_start_jitter) == str: + if not temporal_bin_start_jitter=='random': + raise AttributeError(f'The input temporal_bin_start_jitter as string should only be \'random\'. Other options include float or int. Got {temporal_bin_start_jitter}') + self.temporal_bin_start_jitter = temporal_bin_start_jitter + self.stixel_training_size_threshold = stixel_training_size_threshold self.save_gridding_plot = save_gridding_plot self.save_tmp = save_tmp self.save_dir = save_dir self.sample_weights_for_classifier = sample_weights_for_classifier + # def __sklearn_clone__(self): + # return self + + # def get_params(self, deep=False): + # return { + # 'base_model':self.base_model, + # 'ensemble_fold':self.ensemble_fold, + # 'min_ensemble_require':self.min_ensemble_require, + # 'grid_len_lon_upper_threshold':self.grid_len_lon_upper_threshold, + # 'grid_len_lon_lower_threshold':self.grid_len_lon_lower_threshold, + # 'grid_len_lat_upper_threshold':self.grid_len_lat_upper_threshold, + # 'grid_len_lat_lower_threshold':self.grid_len_lat_lower_threshold, + # 'points_lower_threshold':self.points_lower_threshold, + # 'temporal_start':self.temporal_start, + # 'temporal_end':self.temporal_end, + # 'temporal_step':self.temporal_step, + # 'temporal_bin_interval':self.temporal_bin_interval, + # 'stixel_training_size_threshold':self.stixel_training_size_threshold, + # 'save_gridding_plot':self.save_gridding_plot, + # 'save_tmp':self.save_tmp, + # 'save_dir':self.save_dir, + # 'sample_weights_for_classifier':self.sample_weights_for_classifier + # } + + # def set_params(self, **params): + # if not params: + # return self + + # for key, value in params.items(): + # # if hasattr(self, key): + # # setattr(self, key, value) + # # else: + # self.kwargs[key] = value def split(self, X_train): fold = self.ensemble_fold save_path = os.path.join(self.save_dir, 'ensemble_quadtree_df.csv') if self.save_tmp else '' self.ensemble_df, self.gridding_plot_list = get_ensemble_quadtree(X_train,\ size=fold,\ - grid_len_long_upper_threshold=self.grid_len_long_upper_threshold, \ - grid_len_long_lower_threshold=self.grid_len_long_lower_threshold, \ + grid_len_lon_upper_threshold=self.grid_len_lon_upper_threshold, \ + grid_len_lon_lower_threshold=self.grid_len_lon_lower_threshold, \ grid_len_lat_upper_threshold=self.grid_len_lat_upper_threshold, \ grid_len_lat_lower_threshold=self.grid_len_lat_lower_threshold, \ points_lower_threshold=self.points_lower_threshold, @@ -162,6 +201,7 @@ def split(self, X_train): temporal_end=self.temporal_end, temporal_step=self.temporal_step, temporal_bin_interval = self.temporal_bin_interval, + temporal_bin_start_jitter = self.temporal_bin_start_jitter, save_gridding_plot=self.save_gridding_plot, save_path=save_path) @@ -233,6 +273,11 @@ def fit(self, X_train, y_train): sub_X_train = sub_X_train[self.x_names] unique_sub_y_train_binary = np.unique(np.where(sub_y_train>0, 1, 0)) + ##### nan check + nan_count = np.sum(np.isnan(sub_y_train)) + np.sum(np.isnan(sub_y_train)) + if nan_count>0: + continue + ##### fit if (not self.task == 'regression') and (len(unique_sub_y_train_binary)==1): self.model_dict[f'{name}_model'] = dummy_model1(float(unique_sub_y_train_binary[0])) @@ -244,10 +289,18 @@ def fit(self, X_train, y_train): sample_weights = \ class_weight.compute_sample_weight(class_weight='balanced',y=np.where(sub_y_train>0,1,0)) - self.model_dict[f'{name}_model'].fit(np.array(sub_X_train), np.array(sub_y_train), sample_weight=sample_weights) + try: + self.model_dict[f'{name}_model'].fit(np.array(sub_X_train), np.array(sub_y_train), sample_weight=sample_weights) + except Exception as e: + warnings.warn(e) + continue else: - self.model_dict[f'{name}_model'].fit(np.array(sub_X_train), np.array(sub_y_train)) - + try: + self.model_dict[f'{name}_model'].fit(np.array(sub_X_train), np.array(sub_y_train)) + except Exception as e: + warnings.warn(e) + continue + # ###### store # self.model_dict[f'{name}_model'] = copy.deepcopy(self.base_model) @@ -264,7 +317,7 @@ def predict_proba(self,X_test,verbosity=0): round_res_list = [] ensemble_df = self.ensemble_df - for ensemble in tqdm(list(ensemble_df.ensemble_index.unique())): + for ensemble in list(ensemble_df.ensemble_index.unique()): this_ensemble = ensemble_df[ensemble_df.ensemble_index==ensemble] this_ensemble['stixel_calibration_point_transformed_left_bound'] = \ [i[0] for i in this_ensemble['stixel_calibration_point(transformed)']] @@ -290,11 +343,12 @@ def predict_proba(self,X_test,verbosity=0): grid_index = line['unique_stixel_id'] sub_X_test = X_test_copy[ (X_test_copy.DOY>=line['DOY_start']) & (X_test_copy.DOY<=line['DOY_end']) & \ - (X_test_copy.long_new>=line['stixel_calibration_point_transformed_left_bound']) &\ - (X_test_copy.long_new<=line['stixel_calibration_point_transformed_right_bound']) &\ + (X_test_copy.lon_new>=line['stixel_calibration_point_transformed_left_bound']) &\ + (X_test_copy.lon_new<=line['stixel_calibration_point_transformed_right_bound']) &\ (X_test_copy.lat_new>=line['stixel_calibration_point_transformed_lower_bound']) &\ (X_test_copy.lat_new<=line['stixel_calibration_point_transformed_upper_bound']) ] + if len(sub_X_test)==0: continue @@ -307,7 +361,7 @@ def predict_proba(self,X_test,verbosity=0): try: model = self.model_dict[f'{ensemble}_{grid_index}_model'] - pred = model.predict_proba(sub_X_test)[:,1] + pred = model.predict_proba(np.array(sub_X_test))[:,1] # print(model.predict_proba(sub_X_test).shape, pred.shape) # print(np.sum(pred>0)) @@ -358,8 +412,8 @@ def predict_proba(self,X_test,verbosity=0): nan_count = np.sum(np.isnan(new_res['pred_mean'].values)) nan_frac = nan_count / len(new_res['pred_mean'].values) - # warnings.warn(f'There are {nan_frac}% points ({nan_count} points) fell out of predictable range.') - print(f'There are {nan_frac*100:0.5f}% points ({nan_count} points) fell out of predictable range.') + warnings.warn(f'There are {nan_frac}% points ({nan_count} points) fell out of predictable range.') + # print(f'There are {nan_frac*100:0.5f}% points ({nan_count} points) fell out of predictable range.') return new_res['pred_mean'].values, new_res['pred_std'].values @@ -390,13 +444,13 @@ def transform_pred_set_to_STEM_quad(self,X_train,ensemble_info): long_new = (coord[:,0] + calibration_point_x_jitter).tolist() lat_new = (coord[:,1] + calibration_point_y_jitter).tolist() - X_train['long_new'] = long_new + X_train['lon_new'] = long_new X_train['lat_new'] = lat_new return X_train - - def eval_STEM_res(task, y_test, y_pred): + @classmethod + def eval_STEM_res(self, task, y_test, y_pred, cls_threashold=None): ''' task: one of 'regression', 'classification' or 'hurdle' @@ -419,31 +473,51 @@ def eval_STEM_res(task, y_test, y_pred): if not task in ['regression','classification','hurdle']: raise AttributeError(f'task type must be one of \'regression\', \'classification\', or \'hurdle\'! Now it is {task}') + if cls_threashold==None: + if task=='classification': + cls_threashold = 0.5 + elif task=='hurdle': + cls_threashold = 0 from sklearn.metrics import roc_auc_score, cohen_kappa_score, r2_score, d2_tweedie_score, \ f1_score, precision_score, recall_score, average_precision_score, mean_absolute_error, mean_squared_error from scipy.stats import pearsonr, spearmanr if not task=='regression': - auc = roc_auc_score(np.where(y_test>0, 1, 0), np.where(y_pred>0, 1, 0)) - kappa = cohen_kappa_score(np.where(y_test>0, 1, 0), np.where(y_pred>0, 1, 0)) - f1 = f1_score(np.where(y_test>0, 1, 0), np.where(y_pred>0, 1, 0)) - precision = precision_score(np.where(y_test>0, 1, 0), np.where(y_pred>0, 1, 0)) - recall = recall_score(np.where(y_test>0, 1, 0), np.where(y_pred>0, 1, 0)) - average_precision = average_precision_score(np.where(y_test>0, 1, 0), np.where(y_pred>0, 1, 0)) + + y_test_b = np.where(y_test>cls_threashold, 1, 0) + y_pred_b = np.where(y_pred>cls_threashold, 1, 0) + + if len(np.unique(y_test_b))==1 and len(np.unique(y_pred_b))==1: + auc, kappa, f1, precision, recall, average_precision = [np.nan] * 6 + + else: + auc = roc_auc_score(y_test_b, y_pred_b) + kappa = cohen_kappa_score(y_test_b, y_pred_b) + f1 = f1_score(y_test_b, y_pred_b) + precision = precision_score(y_test_b, y_pred_b) + recall = recall_score(y_test_b, y_pred_b) + average_precision = average_precision_score(y_test_b, y_pred_b) + else: auc, kappa, f1, precision, recall, average_precision = [np.nan] * 6 - a = pd.DataFrame({ - 'y_ture':y_test, - 'pred':y_pred - }).dropna() - s_r, _ = spearmanr(a.y_ture, a.pred) - p_r, _ = pearsonr(a.y_ture, a.pred) - r2 = r2_score(a.y_ture, a.pred) - MAE = mean_absolute_error(a.y_ture, a.pred) - MSE = mean_squared_error(a.y_ture, a.pred) - poisson_deviance_explained = d2_tweedie_score(a[a.pred>0].y_ture, a[a.pred>0].pred, power=1) + if not task=='classification': + a = pd.DataFrame({ + 'y_ture':y_test, + 'pred':y_pred + }).dropna() + s_r, _ = spearmanr(a.y_ture, a.pred) + p_r, _ = pearsonr(a.y_ture, a.pred) + r2 = r2_score(a.y_ture, a.pred) + MAE = mean_absolute_error(a.y_ture, a.pred) + MSE = mean_squared_error(a.y_ture, a.pred) + try: + poisson_deviance_explained = d2_tweedie_score(a[a.pred>0].y_ture, a[a.pred>0].pred, power=1) + except: + poisson_deviance_explained = np.nan + else: + s_r, p_r, r2, MAE, MSE, poisson_deviance_explained = [np.nan] * 6 return { 'AUC':auc, @@ -463,10 +537,11 @@ def eval_STEM_res(task, y_test, y_pred): def score(self, X_test, y_test): y_pred = self.predict(X_test) - score_dict = self.eval_STEM_res(self.task, y_test, y_pred) + score_dict = AdaSTEM.eval_STEM_res(self.task, y_test, y_pred) self.score_dict = score_dict return self.score_dict + @@ -475,8 +550,8 @@ def __init__(self, base_model, task='classification', ensemble_fold=1, min_ensemble_require=1, - grid_len_long_upper_threshold=25, - grid_len_long_lower_threshold=5, + grid_len_lon_upper_threshold=25, + grid_len_lon_lower_threshold=5, grid_len_lat_upper_threshold=25, grid_len_lat_lower_threshold=5, points_lower_threshold=50, @@ -484,6 +559,7 @@ def __init__(self, base_model, temporal_end=366, temporal_step=20, temporal_bin_interval=50, + temporal_bin_start_jitter = 'random', stixel_training_size_threshold=50, save_gridding_plot=True, save_tmp=True, @@ -493,15 +569,23 @@ def __init__(self, base_model, task, ensemble_fold, min_ensemble_require, - grid_len_long_upper_threshold, - grid_len_long_lower_threshold, + grid_len_lon_upper_threshold, + grid_len_lon_lower_threshold, grid_len_lat_upper_threshold, grid_len_lat_lower_threshold, points_lower_threshold, temporal_start, - temporal_end, temporal_step, temporal_bin_interval, stixel_training_size_threshold, + temporal_end, temporal_step, temporal_bin_interval, + temporal_bin_start_jitter, + stixel_training_size_threshold, save_gridding_plot, save_tmp, save_dir, sample_weights_for_classifier) - # self.task='classification' + def predict(self, X_test, verbosity=0, return_std=False): + mean, std = self.predict_proba(X_test, verbosity=verbosity) + if return_std: + return np.where(mean>0.5, 1, 0), std + else: + return np.where(mean>0.5, 1, 0) + class AdaSTEMRegressor(AdaSTEM): @@ -509,8 +593,8 @@ def __init__(self, base_model, task='regression', ensemble_fold=1, min_ensemble_require=1, - grid_len_long_upper_threshold=25, - grid_len_long_lower_threshold=5, + grid_len_lon_upper_threshold=25, + grid_len_lon_lower_threshold=5, grid_len_lat_upper_threshold=25, grid_len_lat_lower_threshold=5, points_lower_threshold=50, @@ -518,6 +602,7 @@ def __init__(self, base_model, temporal_end=366, temporal_step=20, temporal_bin_interval=50, + temporal_bin_start_jitter = 'random', stixel_training_size_threshold=50, save_gridding_plot=True, save_tmp=True, @@ -527,11 +612,13 @@ def __init__(self, base_model, task, ensemble_fold, min_ensemble_require, - grid_len_long_upper_threshold, - grid_len_long_lower_threshold, + grid_len_lon_upper_threshold, + grid_len_lon_lower_threshold, grid_len_lat_upper_threshold, grid_len_lat_lower_threshold, points_lower_threshold, temporal_start, - temporal_end, temporal_step, temporal_bin_interval, stixel_training_size_threshold, + temporal_end, temporal_step, temporal_bin_interval, + temporal_bin_start_jitter, + stixel_training_size_threshold, save_gridding_plot, save_tmp, save_dir, sample_weights_for_classifier) # self.task='regression' @@ -544,8 +631,8 @@ def __init__(self, base_model, task='hurdle', ensemble_fold=1, min_ensemble_require=1, - grid_len_long_upper_threshold=25, - grid_len_long_lower_threshold=5, + grid_len_lon_upper_threshold=25, + grid_len_lon_lower_threshold=5, grid_len_lat_upper_threshold=25, grid_len_lat_lower_threshold=5, points_lower_threshold=50, @@ -553,6 +640,7 @@ def __init__(self, base_model, temporal_end=366, temporal_step=20, temporal_bin_interval=50, + temporal_bin_start_jitter = 'random', stixel_training_size_threshold=50, save_gridding_plot=True, save_tmp=True, @@ -562,11 +650,13 @@ def __init__(self, base_model, task, ensemble_fold, min_ensemble_require, - grid_len_long_upper_threshold, - grid_len_long_lower_threshold, + grid_len_lon_upper_threshold, + grid_len_lon_lower_threshold, grid_len_lat_upper_threshold, grid_len_lat_lower_threshold, points_lower_threshold, temporal_start, - temporal_end, temporal_step, temporal_bin_interval, stixel_training_size_threshold, + temporal_end, temporal_step, temporal_bin_interval, + temporal_bin_start_jitter, + stixel_training_size_threshold, save_gridding_plot, save_tmp, save_dir, sample_weights_for_classifier) # self.task='hurdle' diff --git a/BirdSTEM/model/Hurdle.py b/BirdSTEM/model/Hurdle.py index 48c4cfc..1a16178 100644 --- a/BirdSTEM/model/Hurdle.py +++ b/BirdSTEM/model/Hurdle.py @@ -1,10 +1,10 @@ import numpy as np import warnings from .dummy_model import dummy_model1 +from sklearn.base import BaseEstimator - -class Hurdle(): +class Hurdle(BaseEstimator): def __init__(self, classifier, regressor): ''' The input classifier should have function: diff --git a/BirdSTEM/utils/plot_gif.py b/BirdSTEM/utils/plot_gif.py index fe24816..ad4bdd9 100644 --- a/BirdSTEM/utils/plot_gif.py +++ b/BirdSTEM/utils/plot_gif.py @@ -135,12 +135,13 @@ def animate(i, log_scale=log_scale, legend=False, return_plot_object=False): ax.set_xlim(-180, 180) ax.set_ylim(-90,90) # ax.axis('off') - ax.set_title(f'DOY: {i+1}', fontsize=5) + ax.set_title(f'DOY: {i+1}', fontsize=20) # tt = ax.axes if return_plot_object == True: return scat1, else: + # ax.axis('off') return ax.figure, #scat1.get_children() *scat1, #ax.figure, ### scale the color norm diff --git a/BirdSTEM/utils/quadtree.py b/BirdSTEM/utils/quadtree.py index d8f042d..4e7089b 100644 --- a/BirdSTEM/utils/quadtree.py +++ b/BirdSTEM/utils/quadtree.py @@ -47,16 +47,16 @@ def get_points(self): return self.points -def recursive_subdivide(node, grid_len_long_upper_threshold, grid_len_long_lower_threshold, \ +def recursive_subdivide(node, grid_len_lon_upper_threshold, grid_len_lon_lower_threshold, \ grid_len_lat_upper_threshold, grid_len_lat_lower_threshold, \ points_lower_threshold): if len(node.points)/2 <= points_lower_threshold: - if not ((node.width > grid_len_long_upper_threshold) or (node.height > grid_len_lat_upper_threshold)): + if not ((node.width > grid_len_lon_upper_threshold) or (node.height > grid_len_lat_upper_threshold)): return - if (node.width/2 < grid_len_long_lower_threshold) or (node.height/2 < grid_len_lat_lower_threshold): + if (node.width/2 < grid_len_lon_lower_threshold) or (node.height/2 < grid_len_lat_lower_threshold): return w_ = float(node.width/2) @@ -64,25 +64,25 @@ def recursive_subdivide(node, grid_len_long_upper_threshold, grid_len_long_lower p = contains(node.x0, node.y0, w_, h_, node.points) x1 = Node(node.x0, node.y0, w_, h_, p) - recursive_subdivide(x1, grid_len_long_upper_threshold, grid_len_long_lower_threshold, \ + recursive_subdivide(x1, grid_len_lon_upper_threshold, grid_len_lon_lower_threshold, \ grid_len_lat_upper_threshold, grid_len_lat_lower_threshold, \ points_lower_threshold) p = contains(node.x0, node.y0+h_, w_, h_, node.points) x2 = Node(node.x0, node.y0+h_, w_, h_, p) - recursive_subdivide(x2, grid_len_long_upper_threshold, grid_len_long_lower_threshold, \ + recursive_subdivide(x2, grid_len_lon_upper_threshold, grid_len_lon_lower_threshold, \ grid_len_lat_upper_threshold, grid_len_lat_lower_threshold, \ points_lower_threshold) p = contains(node.x0+w_, node.y0, w_, h_, node.points) x3 = Node(node.x0 + w_, node.y0, w_, h_, p) - recursive_subdivide(x3, grid_len_long_upper_threshold, grid_len_long_lower_threshold, \ + recursive_subdivide(x3, grid_len_lon_upper_threshold, grid_len_lon_lower_threshold, \ grid_len_lat_upper_threshold, grid_len_lat_lower_threshold, \ points_lower_threshold) p = contains(node.x0+w_, node.y0+h_, w_, h_, node.points) x4 = Node(node.x0+w_, node.y0+h_, w_, h_, p) - recursive_subdivide(x4, grid_len_long_upper_threshold, grid_len_long_lower_threshold, \ + recursive_subdivide(x4, grid_len_lon_upper_threshold, grid_len_lon_lower_threshold, \ grid_len_lat_upper_threshold, grid_len_lat_lower_threshold, \ points_lower_threshold) @@ -111,19 +111,19 @@ def find_children(node): import matplotlib.patches as patches class QTree(): - def __init__(self, grid_len_long_upper_threshold, grid_len_long_lower_threshold, \ + def __init__(self, grid_len_lon_upper_threshold, grid_len_lon_lower_threshold, \ grid_len_lat_upper_threshold, grid_len_lat_lower_threshold, \ - points_lower_threshold, long_lat_equal_grid=True,\ + points_lower_threshold, lon_lat_equal_grid=True,\ rotation_angle = 0, \ calibration_point_x_jitter = 0,\ calibration_point_y_jitter = 0): self.points_lower_threshold = points_lower_threshold - self.grid_len_long_upper_threshold = grid_len_long_upper_threshold - self.grid_len_long_lower_threshold = grid_len_long_lower_threshold + self.grid_len_lon_upper_threshold = grid_len_lon_upper_threshold + self.grid_len_lon_lower_threshold = grid_len_lon_lower_threshold self.grid_len_lat_upper_threshold = grid_len_lat_upper_threshold self.grid_len_lat_lower_threshold = grid_len_lat_lower_threshold - self.long_lat_equal_grid = long_lat_equal_grid + self.lon_lat_equal_grid = lon_lat_equal_grid # self.points = [Point(random.uniform(0, 10), random.uniform(0, 10)) for x in range(n)] self.points = [] self.rotation_angle = rotation_angle @@ -131,7 +131,7 @@ def __init__(self, grid_len_long_upper_threshold, grid_len_long_lower_threshold, self.calibration_point_y_jitter = calibration_point_y_jitter - def add_long_lat_data(self, indexes, x_array, y_array): + def add_lon_lat_data(self, indexes, x_array, y_array): if not len(x_array) == len(y_array) or not len(x_array) == len(indexes): raise ValueError("input longitude and latitute and indexes not in same length!") @@ -144,11 +144,11 @@ def add_long_lat_data(self, indexes, x_array, y_array): [np.sin(theta), np.cos(theta)] ]) data = data @ rotation_matrix - long_new = (data[:,0] + self.calibration_point_x_jitter).tolist() + lon_new = (data[:,0] + self.calibration_point_x_jitter).tolist() lat_new = (data[:,1] + self.calibration_point_y_jitter).tolist() - for index,long,lat in zip(indexes, long_new, lat_new): - self.points.append(Point(index, long, lat)) + for index,lon,lat in zip(indexes, lon_new, lat_new): + self.points.append(Point(index, lon, lat)) @@ -162,23 +162,23 @@ def generate_griding_params(self): left_bottom_point_y = np.min(y_list) self.left_bottom_point = (left_bottom_point_x ,left_bottom_point_y) - if self.long_lat_equal_grid == True: + if self.lon_lat_equal_grid == True: self.root = Node(left_bottom_point_x, left_bottom_point_y, \ max(self.grid_length_x, self.grid_length_y), \ max(self.grid_length_x, self.grid_length_y), self.points) - elif self.long_lat_equal_grid == False: + elif self.lon_lat_equal_grid == False: self.root = Node(left_bottom_point_x, left_bottom_point_y, \ self.grid_length_x, \ self.grid_length_y, self.points) else: - raise ValueError('The input long_lat_equal_grid not a boolean value!') + raise ValueError('The input lon_lat_equal_grid not a boolean value!') def get_points(self): return self.points def subdivide(self): - recursive_subdivide(self.root, self.grid_len_long_upper_threshold, self.grid_len_long_lower_threshold, \ + recursive_subdivide(self.root, self.grid_len_lon_upper_threshold, self.grid_len_lon_lower_threshold, \ self.grid_len_lat_upper_threshold, self.grid_len_lat_lower_threshold, \ self.points_lower_threshold) @@ -199,8 +199,8 @@ def graph(self, scatter=True, show=True): width_set.add(el.width) height_set.add(el.height) - # print("Minimum segment area: %.3f units^2, min_long: %.3f units, min_lat: %.3f units" %(min(areas),min(width_set),min(height_set))) - # print("Maximum segment area: %.3f units^2, max_long: %.3f units, max_lat: %.3f units" %(max(areas),max(width_set),max(height_set))) + # print("Minimum segment area: %.3f units^2, min_lon: %.3f units, min_lat: %.3f units" %(min(areas),min(width_set),min(height_set))) + # print("Maximum segment area: %.3f units^2, max_lon: %.3f units, max_lat: %.3f units" %(max(areas),max(width_set),max(height_set))) theta = -(self.rotation_angle/360) * np.pi * 2 rotation_matrix = np.array([ @@ -269,16 +269,19 @@ def get_final_result(self): return result -def generate_temporal_bins(start, end, step, bin_interval): +def generate_temporal_bins(start, end, step, bin_interval, temporal_bin_start_jitter): ''' start, end, step, bin_interval ''' bin_interval = bin_interval #50 step = step #20 - if not bin_interval - step > step: - raise AttributeError('Did not satisfy constrain: bin_interval - step > step') - start = start - np.random.uniform(low=0, high=bin_interval) ### ensure 20 DOY + if type(temporal_bin_start_jitter) == str and temporal_bin_start_jitter=='random': + jit = np.random.uniform(low=0, high=bin_interval) + elif type(temporal_bin_start_jitter) in [int, float]: + jit = temporal_bin_start_jitter + + start = start - jit ### ensure 20 DOY bin_list = [] i=0 @@ -294,10 +297,11 @@ def generate_temporal_bins(start, end, step, bin_interval): def get_ensemble_quadtree(data,size=1, - grid_len_long_upper_threshold=25, grid_len_long_lower_threshold=5, + grid_len_lon_upper_threshold=25, grid_len_lon_lower_threshold=5, grid_len_lat_upper_threshold=25, grid_len_lat_lower_threshold=5, points_lower_threshold=50, temporal_start = 1, temporal_end=366, temporal_step=20, temporal_bin_interval = 50, + temporal_bin_start_jitter = 'random', save_gridding_plot=True, save_path=''): ''' @@ -326,8 +330,9 @@ def get_ensemble_quadtree(data,size=1, temporal_bins = generate_temporal_bins(start = temporal_start, end=temporal_end, step=temporal_step, - bin_interval = temporal_bin_interval) - + bin_interval = temporal_bin_interval, + temporal_bin_start_jitter = temporal_bin_start_jitter) + for time_block_index,bin_ in enumerate(temporal_bins): time_start = bin_[0] @@ -335,19 +340,21 @@ def get_ensemble_quadtree(data,size=1, sub_data=data[(data['DOY']>=time_start) & (data['DOY']0, 1, 0)) +X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.3, + stratify = np.where(y>0, 1, 0), shuffle=True) + + + + +# %% [markdown] +# # Test model + +# %% [markdown] +# ## Task1: Classification (modeling occurrence) + +# %% [markdown] +# ### First, without AdaSTEM wrapper + +# %% +from BirdSTEM.model.AdaSTEM import AdaSTEM, AdaSTEMClassifier +from sklearn.tree import DecisionTreeClassifier +from sklearn.linear_model import LogisticRegression, SGDClassifier +from sklearn.svm import SVC +from sklearn.naive_bayes import GaussianNB, MultinomialNB, ComplementNB +from sklearn.neighbors import KNeighborsClassifier +from sklearn.ensemble import RandomForestClassifier +from xgboost import XGBClassifier +from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis +from sklearn.neural_network import MLPClassifier +from elapid import MaxentModel + + +# %% + +cls_model_set_dict = { + 'LogisticRegression':LogisticRegression(random_state=42), + 'SGDClassifier':SGDClassifier(random_state=42), + 'GaussianNB':GaussianNB(), + 'KNeighborsClassifier':KNeighborsClassifier(), + 'DecisionTreeClassifier':DecisionTreeClassifier(random_state=42), + # 'SVC_linear':SVC(kernel='linear',random_state=42), + 'SVC_rbf':SVC(kernel='rbf',random_state=42), + 'RandomForestClassifier':RandomForestClassifier(random_state=42), + 'QuadraticDiscriminantAnalysis':QuadraticDiscriminantAnalysis(), + 'MLPClassifier':MLPClassifier(random_state=42), + 'MaxEnt':MaxentModel(transform='cloglog', beta_multiplier=2.0), + 'XGBClassifier':XGBClassifier(tree_method='hist',random_state=42, n_jobs=1), + 'ComplementNB':ComplementNB(), +} + + +# %% +K=5 + +cls_metric_df_list = [] +for item in list(cls_model_set_dict.keys())[::-1]: + model_name = item + model = cls_model_set_dict[model_name] + + kf = KFold(n_splits=K, shuffle=True, random_state=42).split(X, y) + for kf_count, (train_index, test_index) in tqdm(enumerate(kf), desc=f'{model_name}', total=K): + + try: + X_train = X.iloc[train_index].replace(-1,np.nan) + imputer = SimpleImputer().fit(X_train[x_names]) + X_train[x_names] = imputer.transform(X_train[x_names]) + scaler = MinMaxScaler().fit(X_train[x_names]) + X_train[x_names] = scaler.transform(X_train[x_names]) + + y_train = np.where(y[train_index]>0, 1, 0) + + X_test = X.iloc[test_index].replace(-1,np.nan) + X_test[x_names] = imputer.transform(X_test[x_names]) + X_test[x_names] = scaler.transform(X_test[x_names]) + y_test = np.where(y[test_index]>0, 1, 0) + + + sample_weights = class_weight.compute_sample_weight(class_weight='balanced',y=y_train) + + a = time.time() + + try: + start_time = time.time() + model.fit(X_train[x_names], y_train, sample_weight=sample_weights) + finish_time = time.time() + training_time = finish_time - start_time + except: + start_time = time.time() + model.fit(X_train[x_names], y_train) + finish_time = time.time() + training_time = finish_time - start_time + + start_time = time.time() + y_pred = model.predict(X_test[x_names]) + finish_time = time.time() + predicting_time = finish_time - start_time + + y_pred = np.where(y_pred<0, 0, y_pred) + metric_df = AdaSTEM.eval_STEM_res('classification', y_test, y_pred) + + metric_df['model'] = model_name + metric_df['task_type'] = 'classification' + metric_df['iter'] = kf_count + metric_df['sp'] = sp + metric_df['sample_size'] = SAMPLE_SIZE + metric_df['training_time'] = training_time + metric_df['predicting_time'] = predicting_time + + cls_metric_df_list.append(metric_df) + + print(metric_df,end='\n') + + except Exception as e: + print(e) + continue + + + + + +# %% +cls_metric_df = pd.DataFrame(cls_metric_df_list) +cls_metric_df.to_csv(os.path.join(OUTPUT_DIR, f'cls_metric_df_SIZE_{SAMPLE_SIZE}_SP_{sp}_year_{year}.csv'), + index=False) + + +# %% [markdown] +# ### Then, with AdaSTEM wrapper + +# %% + +K=5 + +Ada_cls_metric_df_list = [] +for item in list(cls_model_set_dict.keys())[::-1]: + model_name = item + + kf = KFold(n_splits=K, shuffle=True, random_state=42).split(X, y) + for kf_count, (train_index, test_index) in tqdm(enumerate(kf), desc=f'AdaSTEM + {model_name}', total=K): + + try: + X_train = X.iloc[train_index].replace(-1,np.nan) + + new_x_names = list(set(x_names) - set(['DOY'])) + + imputer = SimpleImputer().fit(X_train[new_x_names]) + X_train[new_x_names] = imputer.transform(X_train[new_x_names]) + scaler = MinMaxScaler().fit(X_train[new_x_names]) + X_train[new_x_names] = scaler.transform(X_train[new_x_names]) + + y_train = np.where(y[train_index]>0, 1, 0) + X_test = X.iloc[test_index].replace(-1,np.nan) + X_test[new_x_names] = imputer.transform(X_test[new_x_names]) + X_test[new_x_names] = scaler.transform(X_test[new_x_names]) + y_test = np.where(y[test_index]>0, 1, 0) + + model = AdaSTEMClassifier(base_model=cls_model_set_dict[model_name], + sample_weights_for_classifier=True, + ensemble_fold=5, + min_ensemble_require=3, + grid_len_lon_upper_threshold=25, + grid_len_lon_lower_threshold=5, + grid_len_lat_upper_threshold=25, + grid_len_lat_lower_threshold=5, + points_lower_threshold=50, + stixel_training_size_threshold=50, + temporal_start = 1, + temporal_end = 367, + temporal_step = 30.5, + temporal_bin_interval = 30.5, + save_tmp=False, + save_gridding_plot=False) + + try: + start_time = time.time() + model.fit(X_train[new_x_names + ['DOY','longitude', 'latitude']], y_train) + finish_time = time.time() + training_time = finish_time - start_time + except: + start_time = time.time() + model.set_params(**{'sample_weights_for_classifier':False}) + model.fit(X_train[new_x_names + ['DOY','longitude', 'latitude']], y_train) + finish_time = time.time() + training_time = finish_time - start_time + + start_time = time.time() + y_pred = model.predict(X_test[new_x_names + ['DOY','longitude', 'latitude']]) + finish_time = time.time() + predicting_time = finish_time - start_time + + y_pred = np.where(y_pred<0, 0, y_pred) + metric_df = AdaSTEM.eval_STEM_res('classification', y_test, y_pred) + + metric_df['model'] = 'AdaSTEM_' + model_name + metric_df['task_type'] = 'classification' + metric_df['iter'] = kf_count + metric_df['sp'] = sp + metric_df['sample_size'] = SAMPLE_SIZE + metric_df['training_time'] = training_time + metric_df['predicting_time'] = predicting_time + + Ada_cls_metric_df_list.append(metric_df) + print(metric_df,end='\n') + + except Exception as e: + print(e) + continue + + + + + +# %% +Ada_cls_metric_df = pd.DataFrame(Ada_cls_metric_df_list) +Ada_cls_metric_df.to_csv(os.path.join(OUTPUT_DIR, f'Ada_cls_metric_df_SIZE_{SAMPLE_SIZE}_SP_{sp}_year_{year}.csv'), + index=False) + + +# %% + + +# %% [markdown] +# ## Task2: Regression (Hurdle) + +# %% [markdown] +# ### First, without AdaSTEM wrapper + +# %% +from BirdSTEM.model.AdaSTEM import AdaSTEM, AdaSTEMRegressor, AdaSTEMHurdle +from BirdSTEM.model.Hurdle import Hurdle +from sklearn.tree import DecisionTreeRegressor +from sklearn.linear_model import Lasso, LinearRegression, BayesianRidge, SGDRegressor +from sklearn.neural_network import MLPRegressor, MLPClassifier +from sklearn.svm import SVR +from sklearn.ensemble import RandomForestRegressor +from xgboost import XGBClassifier, XGBRegressor + + +# %% +reg_model_set_dict = { + 'Hurdle_SGDClassifier_SGDRegressor':Hurdle(classifier=SGDClassifier(random_state=42), + regressor=SGDRegressor(random_state=42)), + 'Hurdle_Logistic_Linear':Hurdle(classifier=LogisticRegression(random_state=42), regressor=LinearRegression()), + 'Hurdle_SVC_SVR':Hurdle(classifier=SVC(kernel='rbf'), regressor=SVR(kernel='rbf')), + 'Hurdle_DecisionTreeClassifier_DecisionTreeRegressor':Hurdle(classifier=DecisionTreeClassifier(random_state=42), + regressor=DecisionTreeRegressor(random_state=42)), + 'Hurdle_RandomforestClassifier_RandomforestRegressor':Hurdle(classifier=RandomForestClassifier(random_state=42), + regressor=RandomForestRegressor(random_state=42)), + 'Hurdle_MLPClassifier_MLPRegressor': Hurdle(classifier=MLPClassifier(random_state=42), + regressor=MLPRegressor(random_state=42)), + 'Hurdle_XGBClassifier_XGBregressor': Hurdle(classifier=XGBClassifier(tree_method='hist',n_jobs=1), + regressor=XGBRegressor(tree_method='hist',n_jobs=1)) +} + +# %% +K=5 + +reg_metric_df_list = [] +for item in list(reg_model_set_dict.keys())[::-1]: + model_name = item + model = reg_model_set_dict[model_name] + + kf = KFold(n_splits=K, shuffle=True, random_state=42).split(X, y) + for kf_count, (train_index, test_index) in tqdm(enumerate(kf), desc=f'{model_name}', total=K): + X_train = X.iloc[train_index].replace(-1,np.nan) + imputer = SimpleImputer().fit(X_train[x_names]) + X_train[x_names] = imputer.transform(X_train[x_names]) + scaler = MinMaxScaler().fit(X_train[x_names]) + X_train[x_names] = scaler.transform(X_train[x_names]) + + y_train = np.where(y[train_index]>0, 1, 0) + X_test = X.iloc[test_index].replace(-1,np.nan) + X_test[x_names] = imputer.transform(X_test[x_names]) + X_test[x_names] = scaler.transform(X_test[x_names]) + y_test = np.where(y[test_index]>0, 1, 0) + + sample_weights = class_weight.compute_sample_weight(class_weight='balanced',y=np.where(y_train>0,1,0)) + + + try: + start_time = time.time() + model.fit(X_train[x_names], y_train, sample_weight=sample_weights) + finish_time = time.time() + training_time = finish_time - start_time + except: + start_time = time.time() + model.fit(X_train[x_names], y_train) + finish_time = time.time() + training_time = finish_time - start_time + + start_time = time.time() + y_pred = model.predict(X_test[x_names]) + y_pred = np.where(y_pred<0, 0, y_pred) + finish_time = time.time() + predicting_time = finish_time - start_time + + metric_df = AdaSTEM.eval_STEM_res('hurdle', y_test, np.array(y_pred).flatten()) + metric_df['model'] = model_name + metric_df['task_type'] = 'hurdle' + metric_df['iter'] = kf_count + metric_df['sp'] = sp + metric_df['sample_size'] = SAMPLE_SIZE + metric_df['training_time'] = training_time + metric_df['predicting_time'] = predicting_time + + reg_metric_df_list.append(metric_df) + print(metric_df,end='\n') + + + + +# %% +reg_metric_df = pd.DataFrame(reg_metric_df_list) +reg_metric_df.to_csv(os.path.join(OUTPUT_DIR, f'hurdle_metric_df_SIZE_{SAMPLE_SIZE}_SP_{sp}_year_{year}.csv'), + index=False) + + +# %% + + +# %% [markdown] +# ### Then, with AdaSTEM wrapper + +# %% +K=5 + +reg_metric_df_list = [] +for item in list(reg_model_set_dict.keys())[::-1]: + model_name = item + model = reg_model_set_dict[model_name] + + kf = KFold(n_splits=K, shuffle=True, random_state=42).split(X, y) + for kf_count, (train_index, test_index) in tqdm(enumerate(kf), desc=f'AdaSTEM + {model_name}', total=K): + + try: + X_train = X.iloc[train_index].replace(-1,np.nan) + + new_x_names = list(set(x_names) - set(['DOY'])) + + imputer = SimpleImputer().fit(X_train[new_x_names]) + X_train[new_x_names] = imputer.transform(X_train[new_x_names]) + scaler = MinMaxScaler().fit(X_train[new_x_names]) + X_train[new_x_names] = scaler.transform(X_train[new_x_names]) + + y_train = y[train_index] + X_test = X.iloc[test_index].replace(-1,np.nan) + X_test[new_x_names] = imputer.transform(X_test[new_x_names]) + X_test[new_x_names] = scaler.transform(X_test[new_x_names]) + y_test = y[test_index] + + model = AdaSTEMClassifier(base_model=reg_model_set_dict[model_name], + sample_weights_for_classifier=True, + ensemble_fold=5, + min_ensemble_require=3, + grid_len_lon_upper_threshold=25, + grid_len_lon_lower_threshold=5, + grid_len_lat_upper_threshold=25, + grid_len_lat_lower_threshold=5, + points_lower_threshold=50, + stixel_training_size_threshold=50, + temporal_start = 1, + temporal_end = 367, + temporal_step = 30.5, + temporal_bin_interval = 30.5, + save_tmp=False, + save_gridding_plot=False) + + try: + start_time = time.time() + model.fit(X_train[new_x_names + ['DOY','longitude', 'latitude']], y_train) + finish_time = time.time() + training_time = finish_time - start_time + + except: + start_time = time.time() + model.set_params(**{'sample_weights_for_classifier':False}) + model.fit(X_train[new_x_names + ['DOY','longitude', 'latitude']], y_train) + finish_time = time.time() + training_time = finish_time - start_time + + start_time = time.time() + y_pred = model.predict(X_test[new_x_names + ['DOY','longitude', 'latitude']]) + y_pred = np.where(y_pred<0, 0, y_pred) + finish_time = time.time() + predicting_time_time = finish_time - start_time + + metric_df = AdaSTEM.eval_STEM_res('hurdle', y_test, np.array(y_pred).flatten()) + + metric_df['model'] = 'AdaSTEM_' + model_name + metric_df['task_type'] = 'hurdle' + metric_df['iter'] = kf_count + metric_df['sp'] = sp + metric_df['sample_size'] = SAMPLE_SIZE + metric_df['training_time'] = training_time + metric_df['predicting_time'] = predicting_time + + reg_metric_df_list.append(metric_df) + print(metric_df,end='\n') + + except Exception as e: + print(e) + continue + + + + +# %% +reg_metric_df = pd.DataFrame(reg_metric_df_list) +reg_metric_df.to_csv(os.path.join(OUTPUT_DIR, f'Ada_hurdle_metric_df_SIZE_{SAMPLE_SIZE}_SP_{sp}_year_{year}.csv'), + index=False) + + +# %% +all_metrics = pd.concat([ + pd.read_csv(os.path.join(OUTPUT_DIR, f'cls_metric_df_SIZE_{SAMPLE_SIZE}_SP_{sp}_year_{year}.csv')), + pd.read_csv(os.path.join(OUTPUT_DIR, f'Ada_cls_metric_df_SIZE_{SAMPLE_SIZE}_SP_{sp}_year_{year}.csv')), + pd.read_csv(os.path.join(OUTPUT_DIR, f'hurdle_metric_df_SIZE_{SAMPLE_SIZE}_SP_{sp}_year_{year}.csv')), + pd.read_csv(os.path.join(OUTPUT_DIR, f'Ada_hurdle_metric_df_SIZE_{SAMPLE_SIZE}_SP_{sp}_year_{year}.csv')), +], axis=0) + + +# %% +all_metrics.to_csv(os.path.join(OUTPUT_DIR, f'ALL_metric_df_SIZE_{SAMPLE_SIZE}_SP_{sp}_year_{year}.csv')) + + + +# %% + + + +# %% + + +# %% + + +# %% + + + diff --git a/Test_Multiple_Models.ipynb b/Test_Multiple_Models.ipynb new file mode 100644 index 0000000..dfdb84e --- /dev/null +++ b/Test_Multiple_Models.ipynb @@ -0,0 +1,2920 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import random\n", + "from tqdm.auto import tqdm\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib\n", + "import warnings\n", + "import pickle\n", + "import geopandas as gpd\n", + "import os\n", + "\n", + "# matplotlib.style.use('ggplot')\n", + "# plt.rcParams['axes.facecolor']='w'\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "import time\n", + "\n", + "from sklearn.preprocessing import StandardScaler, MinMaxScaler\n", + "from sklearn.impute import SimpleImputer\n", + "from sklearn.utils import class_weight\n", + "from sklearn.model_selection import KFold\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# import sys\n", + "# import argparse\n", + "# parser = argparse.ArgumentParser(\n", + "# prog='Test Multiple Model',\n", + "# description='For Classification & Hurdle tasks, test the model performace',\n", + "# epilog='')\n", + "# parser.add_argument('-sp', '--species') # option that takes a value\n", + "# parser.add_argument('-year','--year')\n", + "# parser.add_argument('-size', '--sample_size') # on/off flag\n", + "# parser.add_argument('-o','--output_path', default='./Model_Performance/')\n", + "# args = parser.parse_args()\n", + "# print(args)\n", + "\n", + "# sp = args.species\n", + "# year = int(args.year)\n", + "# SAMPLE_SIZE = int(args.sample_size)\n", + "# OUTPUT_DIR = os.path.join(args.output_path, sp)\n", + "\n", + "# if not os.path.exists(OUTPUT_DIR):\n", + "# os.makedirs(OUTPUT_DIR)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "sp = 'Mallard'\n", + "year = 2020\n", + "SAMPLE_SIZE = 1000\n", + "OUTPUT_DIR = f'./Model_Performance/{sp}'\n", + "\n", + "if not os.path.exists(OUTPUT_DIR):\n", + " os.makedirs(OUTPUT_DIR)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "from BirdSTEM.utils.plot_gif import make_sample_gif, make_sample_gif_hexagon\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# load training data\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "checklist_data = pd.read_csv(f'./BirdSTEM/dataset/test_data/checklist_data/checklist_data_filtered_{year}.csv')\n", + "\n", + "### mallard 2020\n", + "with open(f'./BirdSTEM/dataset/test_data/sp_data/{sp}/{sp}_{year}.pkl','rb') as f:\n", + " sp_data = pickle.load(f)\n", + " \n", + "checklist_data = checklist_data.merge(sp_data, on='sampling_event_identifier', how='left')\n", + "checklist_data['count'] = checklist_data['count'].fillna(0)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Train test split" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "from BirdSTEM.dataset.get_test_x_names import get_test_x_names\n", + "\n", + "x_names = get_test_x_names()\n", + "X = checklist_data[['sampling_event_identifier','longitude','latitude'] + x_names]\n", + "y = checklist_data['count'].values\n", + "\n", + "_, X, _, y = train_test_split(X, y, test_size=SAMPLE_SIZE, stratify=np.where(y>0, 1, 0))\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.3,\n", + " stratify = np.where(y>0, 1, 0), shuffle=True)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Test model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Task1: Classification (modeling occurrence)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### First, without AdaSTEM wrapper" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "from BirdSTEM.model.AdaSTEM import AdaSTEM, AdaSTEMClassifier\n", + "from sklearn.tree import DecisionTreeClassifier\n", + "from sklearn.linear_model import LogisticRegression, SGDClassifier\n", + "from sklearn.svm import SVC\n", + "from sklearn.naive_bayes import GaussianNB, MultinomialNB, ComplementNB\n", + "from sklearn.neighbors import KNeighborsClassifier\n", + "from sklearn.ensemble import RandomForestClassifier\n", + "from xgboost import XGBClassifier\n", + "from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis\n", + "from sklearn.neural_network import MLPClassifier\n", + "from elapid import MaxentModel\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "cls_model_set_dict = {\n", + " 'LogisticRegression':LogisticRegression(random_state=42),\n", + " 'SGDClassifier':SGDClassifier(random_state=42),\n", + " 'GaussianNB':GaussianNB(),\n", + " 'KNeighborsClassifier':KNeighborsClassifier(),\n", + " 'DecisionTreeClassifier':DecisionTreeClassifier(random_state=42),\n", + " # 'SVC_linear':SVC(kernel='linear',random_state=42),\n", + " 'SVC_rbf':SVC(kernel='rbf',random_state=42),\n", + " 'RandomForestClassifier':RandomForestClassifier(random_state=42),\n", + " 'QuadraticDiscriminantAnalysis':QuadraticDiscriminantAnalysis(),\n", + " 'MLPClassifier':MLPClassifier(random_state=42),\n", + " 'MaxEnt':MaxentModel(transform='cloglog', beta_multiplier=2.0),\n", + " 'XGBClassifier':XGBClassifier(tree_method='hist',random_state=42, n_jobs=1),\n", + " 'ComplementNB':ComplementNB(),\n", + "}\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "544e2a03d15a4a01830e269a831b2c69", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "ComplementNB: 0%| | 0/5 [00:000, 1, 0)\n", + " \n", + " X_test = X.iloc[test_index].replace(-1,np.nan)\n", + " X_test[x_names] = imputer.transform(X_test[x_names])\n", + " X_test[x_names] = scaler.transform(X_test[x_names])\n", + " y_test = np.where(y[test_index]>0, 1, 0)\n", + " \n", + " \n", + " sample_weights = class_weight.compute_sample_weight(class_weight='balanced',y=y_train)\n", + " \n", + " a = time.time()\n", + "\n", + " try:\n", + " start_time = time.time()\n", + " model.fit(X_train[x_names], y_train, sample_weight=sample_weights)\n", + " finish_time = time.time()\n", + " training_time = finish_time - start_time\n", + " except:\n", + " start_time = time.time()\n", + " model.fit(X_train[x_names], y_train)\n", + " finish_time = time.time()\n", + " training_time = finish_time - start_time\n", + " \n", + " start_time = time.time()\n", + " y_pred = model.predict(X_test[x_names])\n", + " finish_time = time.time()\n", + " predicting_time = finish_time - start_time\n", + " \n", + " y_pred = np.where(y_pred<0, 0, y_pred)\n", + " metric_df = AdaSTEM.eval_STEM_res('classification', y_test, y_pred)\n", + " \n", + " metric_df['model'] = model_name\n", + " metric_df['task_type'] = 'classification'\n", + " metric_df['iter'] = kf_count\n", + " metric_df['sp'] = sp\n", + " metric_df['sample_size'] = SAMPLE_SIZE\n", + " metric_df['training_time'] = training_time\n", + " metric_df['predicting_time'] = predicting_time\n", + " \n", + " cls_metric_df_list.append(metric_df)\n", + " \n", + " print(metric_df)\n", + " \n", + " except Exception as e:\n", + " print(e)\n", + " continue\n", + "\n", + "\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "cls_metric_df = pd.DataFrame(cls_metric_df_list)\n", + "cls_metric_df.to_csv(os.path.join(OUTPUT_DIR, f'cls_metric_df_SIZE_{SAMPLE_SIZE}_SP_{sp}_year_{year}.csv'),\n", + " index=False)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Then, with AdaSTEM wrapper" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6a5d5316629a4b919c6f507ec1863761", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "AdaSTEM + ComplementNB: 0%| | 0/5 [00:000, 1, 0)\n", + " X_test = X.iloc[test_index].replace(-1,np.nan)\n", + " X_test[new_x_names] = imputer.transform(X_test[new_x_names])\n", + " X_test[new_x_names] = scaler.transform(X_test[new_x_names])\n", + " y_test = np.where(y[test_index]>0, 1, 0)\n", + " \n", + " model = AdaSTEMClassifier(base_model=cls_model_set_dict[model_name], \n", + " sample_weights_for_classifier=True,\n", + " ensemble_fold=5,\n", + " min_ensemble_require=3,\n", + " grid_len_lon_upper_threshold=25,\n", + " grid_len_lon_lower_threshold=5,\n", + " grid_len_lat_upper_threshold=25,\n", + " grid_len_lat_lower_threshold=5,\n", + " points_lower_threshold=50,\n", + " stixel_training_size_threshold=50,\n", + " temporal_start = 1,\n", + " temporal_end = 367, \n", + " temporal_step = 30.5, \n", + " temporal_bin_interval = 30.5,\n", + " save_tmp=False, \n", + " save_gridding_plot=False)\n", + " \n", + " try:\n", + " start_time = time.time()\n", + " model.fit(X_train[new_x_names + ['DOY','longitude', 'latitude']], y_train)\n", + " finish_time = time.time()\n", + " training_time = finish_time - start_time\n", + " except:\n", + " start_time = time.time()\n", + " model.set_params(**{'sample_weights_for_classifier':False})\n", + " model.fit(X_train[new_x_names + ['DOY','longitude', 'latitude']], y_train)\n", + " finish_time = time.time()\n", + " training_time = finish_time - start_time\n", + " \n", + " start_time = time.time()\n", + " y_pred = model.predict(X_test[new_x_names + ['DOY','longitude', 'latitude']])\n", + " finish_time = time.time()\n", + " predicting_time = finish_time - start_time\n", + " \n", + " y_pred = np.where(y_pred<0, 0, y_pred)\n", + " metric_df = AdaSTEM.eval_STEM_res('classification', y_test, y_pred)\n", + " \n", + " metric_df['model'] = 'AdaSTEM_' + model_name\n", + " metric_df['task_type'] = 'classification'\n", + " metric_df['iter'] = kf_count\n", + " metric_df['sp'] = sp\n", + " metric_df['sample_size'] = SAMPLE_SIZE\n", + " metric_df['training_time'] = training_time\n", + " metric_df['predicting_time'] = predicting_time\n", + " \n", + " Ada_cls_metric_df_list.append(metric_df)\n", + " print(metric_df)\n", + " \n", + " except Exception as e:\n", + " print(e)\n", + " continue\n", + "\n", + "\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "Ada_cls_metric_df = pd.DataFrame(Ada_cls_metric_df_list)\n", + "Ada_cls_metric_df.to_csv(os.path.join(OUTPUT_DIR, f'Ada_cls_metric_df_SIZE_{SAMPLE_SIZE}_SP_{sp}_year_{year}.csv'),\n", + " index=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Task2: Regression (Hurdle)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### First, without AdaSTEM wrapper" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "from BirdSTEM.model.AdaSTEM import AdaSTEM, AdaSTEMRegressor, AdaSTEMHurdle\n", + "from BirdSTEM.model.Hurdle import Hurdle\n", + "from sklearn.tree import DecisionTreeRegressor\n", + "from sklearn.linear_model import Lasso, LinearRegression, BayesianRidge, SGDRegressor\n", + "from sklearn.neural_network import MLPRegressor, MLPClassifier\n", + "from sklearn.svm import SVR\n", + "from sklearn.ensemble import RandomForestRegressor\n", + "from xgboost import XGBClassifier, XGBRegressor\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "reg_model_set_dict = {\n", + " 'Hurdle_SGDClassifier_SGDRegressor':Hurdle(classifier=SGDClassifier(random_state=42), \n", + " regressor=SGDRegressor(random_state=42)),\n", + " 'Hurdle_Logistic_Linear':Hurdle(classifier=LogisticRegression(random_state=42), regressor=LinearRegression()),\n", + " 'Hurdle_SVC_SVR':Hurdle(classifier=SVC(kernel='rbf'), regressor=SVR(kernel='rbf')),\n", + " 'Hurdle_DecisionTreeClassifier_DecisionTreeRegressor':Hurdle(classifier=DecisionTreeClassifier(random_state=42),\n", + " regressor=DecisionTreeRegressor(random_state=42)),\n", + " 'Hurdle_RandomforestClassifier_RandomforestRegressor':Hurdle(classifier=RandomForestClassifier(random_state=42),\n", + " regressor=RandomForestRegressor(random_state=42)),\n", + " 'Hurdle_MLPClassifier_MLPRegressor': Hurdle(classifier=MLPClassifier(random_state=42),\n", + " regressor=MLPRegressor(random_state=42)),\n", + " 'Hurdle_XGBClassifier_XGBregressor': Hurdle(classifier=XGBClassifier(tree_method='hist',n_jobs=1), \n", + " regressor=XGBRegressor(tree_method='hist',n_jobs=1))\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "53887fcc59164b05945d2864f1e164cb", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Hurdle_XGBClassifier_XGBregressor: 0%| | 0/5 [00:000, 1, 0)\n", + " X_test = X.iloc[test_index].replace(-1,np.nan)\n", + " X_test[x_names] = imputer.transform(X_test[x_names])\n", + " X_test[x_names] = scaler.transform(X_test[x_names])\n", + " y_test = np.where(y[test_index]>0, 1, 0)\n", + " \n", + " sample_weights = class_weight.compute_sample_weight(class_weight='balanced',y=np.where(y_train>0,1,0))\n", + " \n", + " \n", + " try:\n", + " start_time = time.time()\n", + " model.fit(X_train[x_names], y_train, sample_weight=sample_weights)\n", + " finish_time = time.time()\n", + " training_time = finish_time - start_time\n", + " except:\n", + " start_time = time.time()\n", + " model.fit(X_train[x_names], y_train)\n", + " finish_time = time.time()\n", + " training_time = finish_time - start_time\n", + " \n", + " start_time = time.time()\n", + " y_pred = model.predict(X_test[x_names])\n", + " y_pred = np.where(y_pred<0, 0, y_pred)\n", + " finish_time = time.time()\n", + " predicting_time = finish_time - start_time\n", + " \n", + " metric_df = AdaSTEM.eval_STEM_res('hurdle', y_test, np.array(y_pred).flatten())\n", + " metric_df['model'] = model_name\n", + " metric_df['task_type'] = 'hurdle'\n", + " metric_df['iter'] = kf_count\n", + " metric_df['sp'] = sp\n", + " metric_df['sample_size'] = SAMPLE_SIZE\n", + " metric_df['training_time'] = training_time\n", + " metric_df['predicting_time'] = predicting_time\n", + " \n", + " reg_metric_df_list.append(metric_df)\n", + " print(metric_df)\n", + "\n", + "\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "reg_metric_df = pd.DataFrame(reg_metric_df_list)\n", + "reg_metric_df.to_csv(os.path.join(OUTPUT_DIR, f'hurdle_metric_df_SIZE_{SAMPLE_SIZE}_SP_{sp}_year_{year}.csv'),\n", + " index=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Then, with AdaSTEM wrapper" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ffd1d60643b846e1a2fcd9787bac79b6", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "AdaSTEM + Hurdle_XGBClassifier_XGBregressor: 0%| | 0/5 [00:000],\n", + " new_background\n", + "], axis=0)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [], + "source": [ + "from BirdSTEM.dataset.get_test_x_names import get_test_x_names\n", + "x_names = get_test_x_names()\n", + "sampling_effort_vars = ['duration_minutes',\n", + " 'Traveling',\n", + " 'Stationary',\n", + " 'Area',\n", + " 'effort_distance_km',\n", + " 'number_observers',\n", + " 'obsvr_species_count',\n", + " 'time_observation_started_minute_of_day']\n", + "x_names = list(set(x_names) - set(sampling_effort_vars)) ## remove sampling effor since background points dont have one\n", + "\n", + "X = presence_plus_background[['sampling_event_identifier','longitude','latitude'] + x_names]\n", + "# y = np.where(checklist_data['count']>0, 1, 0)\n", + "y = presence_plus_background['count'].fillna(0).values\n", + "\n", + "X[x_names] = X[x_names].replace(-1, np.nan)\n", + "from sklearn.impute import SimpleImputer\n", + "imputer = SimpleImputer(strategy='mean').fit(X[x_names])\n", + "X[x_names] = imputer.transform(X[x_names])\n", + "\n", + "from sklearn.model_selection import train_test_split\n", + "_, X, _, y = train_test_split(X, y, test_size=100000, stratify=np.where(y>0,1,0)) ### reduce the training size\n" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [], + "source": [ + "from sklearn.model_selection import train_test_split\n", + "X_train, X_test, y_train, y_test = train_test_split(X, y, random_state=42, test_size=0.3,\n", + " stratify = np.where(y>0, 1, 0), shuffle=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Generating Ensemble: 100%|██████████| 5/5 [00:06<00:00, 1.24s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Saved! ./ensemble_quadtree_df.csv\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "training: 100%|██████████| 97/97 [06:21<00:00, 3.93s/it]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training AUC score: 0.897\n", + "Testing AUC score: 0.912\n" + ] + } + ], + "source": [ + "# train the model\n", + "model = AdaSTEMClassifier(\n", + " base_model=ela.MaxentModel(transform='cloglog', beta_multiplier=2.0, clamp=False),\n", + " ensemble_fold=5,\n", + " min_ensemble_require=3,\n", + " grid_len_lon_lower_threshold=8888,\n", + " grid_len_lon_upper_threshold=8888,\n", + " grid_len_lat_lower_threshold=8888,\n", + " grid_len_lat_upper_threshold=8888\n", + " )\n", + "\n", + "\n", + "model.fit(X_train[x_names + ['longitude','latitude']], np.where(y_train>0,1,0))\n", + "\n", + "# evaluate training performance\n", + "ypred = model.predict(X_train[x_names + ['longitude','latitude']])\n", + "auc1 = metrics.roc_auc_score(np.where(y_train>0,1,0), np.where(ypred>0.5, 1, 0))\n", + "print(f\"Training AUC score: {auc1:0.3f}\")\n", + "ypred = model.predict(X_test[x_names + ['longitude','latitude']])\n", + "auc2 = metrics.roc_auc_score(np.where(y_test>0,1,0), np.where(ypred>0.5, 1, 0))\n", + "print(f\"Testing AUC score: {auc2:0.3f}\")\n", + "\n", + "# save the fitted model to disk\n", + "ela.save_object(model, 'demo-maxent-model.ela')" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": {}, + "outputs": [], + "source": [ + "aa = checklist_data[x_names + ['longitude','latitude']]\n", + "aa[x_names] = imputer.transform(aa[x_names].replace(-1,np.nan))\n", + "true_pred = model.predict(\n", + " aa # this include true absence, and no background\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True AUC score: 0.500 (probably still a little bit higher)\n" + ] + } + ], + "source": [ + "auc3 = metrics.roc_auc_score(np.where(checklist_data['count']>0,1,0), np.where(true_pred>0.5, 1, 0))\n", + "print(f\"True AUC score: {auc3:0.3f} (probably still a little bit higher)\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Predict on pred_set" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from BirdSTEM.utils.plot_gif import *\n", + "from tqdm.auto import tqdm\n", + "global SAVE_DIR\n", + "SAVE_DIR = f'./test_output/{test_sp}/{year}'\n", + "if not os.path.exists(SAVE_DIR):\n", + " os.makedirs(SAVE_DIR)" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9fba168dfba140e8a0d51148a9bfee16", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/366 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "make_sample_gif_hexagon(pred_whole_year , os.path.join(SAVE_DIR, 'Sample_prediction_results.gif'), \n", + " col='pred_mean_absolute', log_scale=True, dpi=100, fps=30)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# AdaSTEM" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Generating Ensemble: 100%|██████████| 5/5 [00:02<00:00, 1.94it/s]\n", + "training: 100%|██████████| 712/712 [00:36<00:00, 19.48it/s] \n" + ] + } + ], + "source": [ + "from sklearn.model_selection import KFold\n", + "from BirdSTEM.model.AdaSTEM import AdaSTEMClassifier\n", + "base_model = ela.MaxentModel(transform='cloglog', beta_multiplier=2.0)\n", + "\n", + "# new_X_train = X_train.copy()\n", + "# new_X_train['DOY'] = 1\n", + "clf2 = AdaSTEMClassifier(base_model, \n", + " ensemble_fold=5, \n", + " min_ensemble_require=3, \n", + " grid_len_long_upper_threshold=50,\n", + " grid_len_long_lower_threshold=10,\n", + " grid_len_lat_upper_threshold=50,\n", + " grid_len_lat_lower_threshold=10,\n", + " points_lower_threshold=50,\n", + " temporal_start=-1,\n", + " temporal_end=1, \n", + " temporal_step=1000, \n", + " temporal_bin_interval=1000,\n", + " temporal_bin_start_jitter = 0, ## random, or a float/int\n", + " stixel_training_size_threshold=50,\n", + " save_gridding_plot=False, \n", + " save_tmp=False, \n", + " save_dir='./', \n", + " sample_weights_for_classifier=False)\n", + "clf2.fit(X_train[x_names + ['longitude','latitude']], np.where(y_train>0,1,0))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Training: 1.0\n", + "Testing: 0.7355776558451455\n" + ] + } + ], + "source": [ + "# evaluate training performance\n", + "mean, std = clf2.predict_proba(X_train[x_names + ['longitude','latitude']])\n", + "a = pd.DataFrame({\n", + " 'y_train':np.where(y_train>0,1,0), \n", + " 'y_pred':mean\n", + "}).dropna()\n", + "auc1 = metrics.roc_auc_score(a.y_train, a.y_pred)\n", + "print('Training:', auc1)\n", + "\n", + "\n", + "mean, std = clf2.predict_proba(X_test[x_names + ['longitude','latitude']])\n", + "a = pd.DataFrame({\n", + " 'y_test':np.where(y_test>0,1,0), \n", + " 'y_pred':mean\n", + "}).dropna()\n", + "auc2 = metrics.roc_auc_score(a.y_test, a.y_pred)\n", + "print('Testing:', auc2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "y_test 0\n", + "y_pred 21246\n", + "dtype: int64" + ] + }, + "execution_count": 100, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame({\n", + " 'y_test':np.where(y_test>0,1,0), \n", + " 'y_pred':mean\n", + "}).isnull().sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(30000, 2)" + ] + }, + "execution_count": 101, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.DataFrame({\n", + " 'y_test':np.where(y_test>0,1,0), \n", + " 'y_pred':mean\n", + "}).shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/test_with_real_data.ipynb b/test_with_real_data.ipynb index b044a85..846c417 100644 --- a/test_with_real_data.ipynb +++ b/test_with_real_data.ipynb @@ -17,9 +17,10 @@ "import geopandas as gpd\n", "import os\n", "\n", - "matplotlib.style.use('ggplot')\n", - "\n", - "warnings.filterwarnings('ignore')" + "# matplotlib.style.use('ggplot')\n", + "# plt.rcParams['axes.facecolor']='w'\n", + "warnings.filterwarnings('ignore')\n", + "%matplotlib inline" ] }, { @@ -38,44 +39,53 @@ "metadata": {}, "outputs": [], "source": [ - "\n", "from BirdSTEM.dataset.generate_random_samples import generate_fake_dataset\n", "from BirdSTEM.utils.plot_gif import make_sample_gif, make_sample_gif_hexagon\n" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "test_sp = 'Short-eared_Owl'\n", + "year = 2020\n" + ] + }, + { + "cell_type": "code", + "execution_count": 35, "metadata": {}, "outputs": [], "source": [ - "checklist_data = pd.read_csv('./BirdSTEM/dataset/test_data/checklist_data/checklist_data_filtered_2020.csv')" + "checklist_data = pd.read_csv(f'./BirdSTEM/dataset/test_data/checklist_data/checklist_data_filtered_{year}.csv')" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 36, "metadata": {}, "outputs": [], "source": [ "### mallard 2020\n", - "with open('./BirdSTEM/dataset/test_data/sp_data/Great_Tit/Great_Tit_2020.pkl','rb') as f:\n", + "with open(f'./BirdSTEM/dataset/test_data/sp_data/{test_sp}/{test_sp}_{year}.pkl','rb') as f:\n", " sp_data = pickle.load(f)\n", " " ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 37, "metadata": {}, "outputs": [], "source": [ - "checklist_data = checklist_data.merge(sp_data, on='sampling_event_identifier', how='left')" + "checklist_data = checklist_data.merge(sp_data, on='sampling_event_identifier', how='left')\n" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 38, "metadata": {}, "outputs": [], "source": [ @@ -91,7 +101,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 39, "metadata": {}, "outputs": [], "source": [ @@ -391,7 +401,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 40, "metadata": {}, "outputs": [], "source": [ @@ -418,7 +428,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 41, "metadata": {}, "outputs": [], "source": [ @@ -527,7 +537,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 42, "metadata": {}, "outputs": [], "source": [ @@ -539,7 +549,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 43, "metadata": {}, "outputs": [], "source": [ @@ -548,62 +558,43 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 44, "metadata": {}, "outputs": [], "source": [ "global SAVE_DIR\n", - "SAVE_DIR = './test_output'" + "SAVE_DIR = f'./test_output/{test_sp}/{year}'\n", + "if not os.path.exists(SAVE_DIR):\n", + " os.makedirs(SAVE_DIR)\n", + " " ] }, { "cell_type": "code", - "execution_count": 100, + "execution_count": 45, "metadata": {}, "outputs": [], "source": [ "base_model = Hurdle(classifier=XGBClassifier(tree_method='hist',random_state=42, verbosity = 0, n_jobs=1),\n", - " regressor=XGBRegressor(tree_method='hist',random_state=42, verbosity = 0, n_jobs=1))\n", - "\n", - "# base_model = Hurdle(classifier=DecisionTreeClassifier(),\n", - "# regressor=DecisionTreeRegressor())\n", - "\n", - "\n", - "# base_model = XGBRegressor(random_state=42, verbosity=0, n_jobs=1)\n" + " regressor=XGBRegressor(tree_method='hist',random_state=42, verbosity = 0, n_jobs=1))\n" ] }, { "cell_type": "code", - "execution_count": 108, + "execution_count": 46, "metadata": {}, "outputs": [], "source": [ - "# model = AdaSTEM(base_model=base_model,\n", - "# task='hurdle',\n", - "# ensemble_fold = 2,\n", - "# min_ensemble_require= 1,\n", - "# grid_len_long_upper_threshold=25,\n", - "# grid_len_long_lower_threshold=10,\n", - "# grid_len_lat_upper_threshold=25,\n", - "# grid_len_lat_lower_threshold=10,\n", - "# points_lower_threshold=10,\n", - "# temporal_start = 1, temporal_end=366, temporal_step=20, temporal_bin_interval = 50,\n", - "# stixel_training_size_threshold = 10, ## important\n", - "# save_gridding_plot = True,\n", - "# save_tmp = True,\n", - "# save_dir='./',\n", - "# sample_weights_for_classifier=True)\n", - "\n", "model = AdaSTEMHurdle(base_model=base_model,\n", " ensemble_fold = 10,\n", " min_ensemble_require= 7,\n", - " grid_len_long_upper_threshold=25,\n", + " grid_len_long_upper_threshold=50,\n", " grid_len_long_lower_threshold=10,\n", - " grid_len_lat_upper_threshold=25,\n", + " grid_len_lat_upper_threshold=50,\n", " grid_len_lat_lower_threshold=10,\n", - " points_lower_threshold=30,\n", + " points_lower_threshold = 50,\n", " temporal_start = 1, temporal_end=366, temporal_step=20, temporal_bin_interval = 50,\n", - " stixel_training_size_threshold = 30, ## important, should be consistent with points_lower_threshold\n", + " stixel_training_size_threshold = 50, ## important, should be consistent with points_lower_threshold\n", " save_gridding_plot = True,\n", " save_tmp = True,\n", " save_dir=SAVE_DIR,\n", @@ -613,208 +604,75 @@ }, { "cell_type": "code", - "execution_count": 109, + "execution_count": 47, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "Generating Ensemble: 0%| | 0/10 [00:04 1\u001b[0m model\u001b[39m.\u001b[39;49mfit(X_train,y_train)\n", - "File \u001b[0;32m~/Desktop/Project_BirdSTEM/my_package/BirdSTEM/model/AdaSTEM.py:221\u001b[0m, in \u001b[0;36mAdaSTEM.fit\u001b[0;34m(self, X_train, y_train)\u001b[0m\n\u001b[1;32m 218\u001b[0m X_train_copy \u001b[39m=\u001b[39m X_train\u001b[39m.\u001b[39mcopy()\u001b[39m.\u001b[39mreset_index(drop\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m) \u001b[39m### I reset index here!! caution!\u001b[39;00m\n\u001b[1;32m 219\u001b[0m X_train_copy[\u001b[39m'\u001b[39m\u001b[39mtrue_y\u001b[39m\u001b[39m'\u001b[39m] \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray(y_train)\n\u001b[0;32m--> 221\u001b[0m grid_dict \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msplit(X_train_copy)\n\u001b[1;32m 223\u001b[0m \u001b[39m##### define model dict\u001b[39;00m\n\u001b[1;32m 224\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mmodel_dict \u001b[39m=\u001b[39m {}\n", - "File \u001b[0;32m~/Desktop/Project_BirdSTEM/my_package/BirdSTEM/model/AdaSTEM.py:154\u001b[0m, in \u001b[0;36mAdaSTEM.split\u001b[0;34m(self, X_train)\u001b[0m\n\u001b[1;32m 152\u001b[0m fold \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mensemble_fold\n\u001b[1;32m 153\u001b[0m save_path \u001b[39m=\u001b[39m os\u001b[39m.\u001b[39mpath\u001b[39m.\u001b[39mjoin(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39msave_dir, \u001b[39m'\u001b[39m\u001b[39mensemble_quadtree_df.csv\u001b[39m\u001b[39m'\u001b[39m) \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39msave_tmp \u001b[39melse\u001b[39;00m \u001b[39m'\u001b[39m\u001b[39m'\u001b[39m\n\u001b[0;32m--> 154\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mensemble_df, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mgridding_plot_list \u001b[39m=\u001b[39m get_ensemble_quadtree(X_train,\\\n\u001b[1;32m 155\u001b[0m size\u001b[39m=\u001b[39;49mfold,\\\n\u001b[1;32m 156\u001b[0m grid_len_long_upper_threshold\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mgrid_len_long_upper_threshold, \\\n\u001b[1;32m 157\u001b[0m grid_len_long_lower_threshold\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mgrid_len_long_lower_threshold, \\\n\u001b[1;32m 158\u001b[0m grid_len_lat_upper_threshold\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mgrid_len_lat_upper_threshold, \\\n\u001b[1;32m 159\u001b[0m grid_len_lat_lower_threshold\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mgrid_len_lat_lower_threshold, \\\n\u001b[1;32m 160\u001b[0m points_lower_threshold\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mpoints_lower_threshold,\n\u001b[1;32m 161\u001b[0m temporal_start \u001b[39m=\u001b[39;49m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mtemporal_start, \n\u001b[1;32m 162\u001b[0m temporal_end\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mtemporal_end, \n\u001b[1;32m 163\u001b[0m temporal_step\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mtemporal_step, \n\u001b[1;32m 164\u001b[0m temporal_bin_interval \u001b[39m=\u001b[39;49m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mtemporal_bin_interval,\n\u001b[1;32m 165\u001b[0m save_gridding_plot\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49msave_gridding_plot,\n\u001b[1;32m 166\u001b[0m save_path\u001b[39m=\u001b[39;49msave_path)\n\u001b[1;32m 168\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mgrid_dict \u001b[39m=\u001b[39m {}\n\u001b[1;32m 169\u001b[0m \u001b[39mfor\u001b[39;00m ensemble_index \u001b[39min\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mensemble_df\u001b[39m.\u001b[39mensemble_index\u001b[39m.\u001b[39munique():\n", - "File \u001b[0;32m~/Desktop/Project_BirdSTEM/my_package/BirdSTEM/utils/quadtree.py:335\u001b[0m, in \u001b[0;36mget_ensemble_quadtree\u001b[0;34m(data, size, grid_len_long_upper_threshold, grid_len_long_lower_threshold, grid_len_lat_upper_threshold, grid_len_lat_lower_threshold, points_lower_threshold, temporal_start, temporal_end, temporal_step, temporal_bin_interval, save_gridding_plot, save_path)\u001b[0m\n\u001b[1;32m 333\u001b[0m time_start \u001b[39m=\u001b[39m bin_[\u001b[39m0\u001b[39m]\n\u001b[1;32m 334\u001b[0m time_end \u001b[39m=\u001b[39m bin_[\u001b[39m1\u001b[39m]\n\u001b[0;32m--> 335\u001b[0m sub_data\u001b[39m=\u001b[39mdata[(data[\u001b[39m'\u001b[39;49m\u001b[39mDOY\u001b[39;49m\u001b[39m'\u001b[39;49m]\u001b[39m>\u001b[39;49m\u001b[39m=\u001b[39;49mtime_start) \u001b[39m&\u001b[39;49m (data[\u001b[39m'\u001b[39;49m\u001b[39mDOY\u001b[39;49m\u001b[39m'\u001b[39;49m]\u001b[39m<\u001b[39;49mtime_end)]\n\u001b[1;32m 338\u001b[0m QT_obj \u001b[39m=\u001b[39m QTree(grid_len_long_upper_threshold\u001b[39m=\u001b[39mgrid_len_long_upper_threshold, \\\n\u001b[1;32m 339\u001b[0m grid_len_long_lower_threshold\u001b[39m=\u001b[39mgrid_len_long_lower_threshold, \\\n\u001b[1;32m 340\u001b[0m grid_len_lat_upper_threshold\u001b[39m=\u001b[39mgrid_len_lat_upper_threshold, \\\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 345\u001b[0m calibration_point_x_jitter \u001b[39m=\u001b[39m calibration_point_x_jitter,\\\n\u001b[1;32m 346\u001b[0m calibration_point_y_jitter \u001b[39m=\u001b[39m calibration_point_y_jitter)\n\u001b[1;32m 348\u001b[0m \u001b[39m## Give the data and indexes. The indexes should be used to assign points data so that base model can run on those points,\u001b[39;00m\n\u001b[1;32m 349\u001b[0m \u001b[39m## You need to generate the splitting parameters once giving the data. Like the calibration point and min,max.\u001b[39;00m\n", - "File \u001b[0;32m~/miniforge3/lib/python3.9/site-packages/pandas/core/frame.py:3752\u001b[0m, in \u001b[0;36mDataFrame.__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 3750\u001b[0m \u001b[39m# Do we have a (boolean) 1d indexer?\u001b[39;00m\n\u001b[1;32m 3751\u001b[0m \u001b[39mif\u001b[39;00m com\u001b[39m.\u001b[39mis_bool_indexer(key):\n\u001b[0;32m-> 3752\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_getitem_bool_array(key)\n\u001b[1;32m 3754\u001b[0m \u001b[39m# We are left with two options: a single key, and a collection of keys,\u001b[39;00m\n\u001b[1;32m 3755\u001b[0m \u001b[39m# We interpret tuples as collections only for non-MultiIndex\u001b[39;00m\n\u001b[1;32m 3756\u001b[0m is_single_key \u001b[39m=\u001b[39m \u001b[39misinstance\u001b[39m(key, \u001b[39mtuple\u001b[39m) \u001b[39mor\u001b[39;00m \u001b[39mnot\u001b[39;00m is_list_like(key)\n", - "File \u001b[0;32m~/miniforge3/lib/python3.9/site-packages/pandas/core/frame.py:3811\u001b[0m, in \u001b[0;36mDataFrame._getitem_bool_array\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 3808\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mcopy(deep\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m)\n\u001b[1;32m 3810\u001b[0m indexer \u001b[39m=\u001b[39m key\u001b[39m.\u001b[39mnonzero()[\u001b[39m0\u001b[39m]\n\u001b[0;32m-> 3811\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_take_with_is_copy(indexer, axis\u001b[39m=\u001b[39;49m\u001b[39m0\u001b[39;49m)\n", - "File \u001b[0;32m~/miniforge3/lib/python3.9/site-packages/pandas/core/generic.py:3948\u001b[0m, in \u001b[0;36mNDFrame._take_with_is_copy\u001b[0;34m(self, indices, axis)\u001b[0m\n\u001b[1;32m 3940\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m_take_with_is_copy\u001b[39m(\u001b[39mself\u001b[39m: NDFrameT, indices, axis: Axis \u001b[39m=\u001b[39m \u001b[39m0\u001b[39m) \u001b[39m-\u001b[39m\u001b[39m>\u001b[39m NDFrameT:\n\u001b[1;32m 3941\u001b[0m \u001b[39m \u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 3942\u001b[0m \u001b[39m Internal version of the `take` method that sets the `_is_copy`\u001b[39;00m\n\u001b[1;32m 3943\u001b[0m \u001b[39m attribute to keep track of the parent dataframe (using in indexing\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 3946\u001b[0m \u001b[39m See the docstring of `take` for full explanation of the parameters.\u001b[39;00m\n\u001b[1;32m 3947\u001b[0m \u001b[39m \"\"\"\u001b[39;00m\n\u001b[0;32m-> 3948\u001b[0m result \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_take(indices\u001b[39m=\u001b[39;49mindices, axis\u001b[39m=\u001b[39;49maxis)\n\u001b[1;32m 3949\u001b[0m \u001b[39m# Maybe set copy if we didn't actually change the index.\u001b[39;00m\n\u001b[1;32m 3950\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m result\u001b[39m.\u001b[39m_get_axis(axis)\u001b[39m.\u001b[39mequals(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_get_axis(axis)):\n", - "File \u001b[0;32m~/miniforge3/lib/python3.9/site-packages/pandas/core/generic.py:3932\u001b[0m, in \u001b[0;36mNDFrame._take\u001b[0;34m(self, indices, axis, convert_indices)\u001b[0m\n\u001b[1;32m 3924\u001b[0m \u001b[39mif\u001b[39;00m (\n\u001b[1;32m 3925\u001b[0m axis \u001b[39m==\u001b[39m \u001b[39m0\u001b[39m\n\u001b[1;32m 3926\u001b[0m \u001b[39mand\u001b[39;00m indices\u001b[39m.\u001b[39mndim \u001b[39m==\u001b[39m \u001b[39m1\u001b[39m\n\u001b[1;32m 3927\u001b[0m \u001b[39mand\u001b[39;00m using_copy_on_write()\n\u001b[1;32m 3928\u001b[0m \u001b[39mand\u001b[39;00m is_range_indexer(indices, \u001b[39mlen\u001b[39m(\u001b[39mself\u001b[39m))\n\u001b[1;32m 3929\u001b[0m ):\n\u001b[1;32m 3930\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mcopy(deep\u001b[39m=\u001b[39m\u001b[39mNone\u001b[39;00m)\n\u001b[0;32m-> 3932\u001b[0m new_data \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_mgr\u001b[39m.\u001b[39;49mtake(\n\u001b[1;32m 3933\u001b[0m indices,\n\u001b[1;32m 3934\u001b[0m axis\u001b[39m=\u001b[39;49m\u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_get_block_manager_axis(axis),\n\u001b[1;32m 3935\u001b[0m verify\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m,\n\u001b[1;32m 3936\u001b[0m convert_indices\u001b[39m=\u001b[39;49mconvert_indices,\n\u001b[1;32m 3937\u001b[0m )\n\u001b[1;32m 3938\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_constructor(new_data)\u001b[39m.\u001b[39m__finalize__(\u001b[39mself\u001b[39m, method\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mtake\u001b[39m\u001b[39m\"\u001b[39m)\n", - "File \u001b[0;32m~/miniforge3/lib/python3.9/site-packages/pandas/core/internals/managers.py:963\u001b[0m, in \u001b[0;36mBaseBlockManager.take\u001b[0;34m(self, indexer, axis, verify, convert_indices)\u001b[0m\n\u001b[1;32m 960\u001b[0m indexer \u001b[39m=\u001b[39m maybe_convert_indices(indexer, n, verify\u001b[39m=\u001b[39mverify)\n\u001b[1;32m 962\u001b[0m new_labels \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39maxes[axis]\u001b[39m.\u001b[39mtake(indexer)\n\u001b[0;32m--> 963\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49mreindex_indexer(\n\u001b[1;32m 964\u001b[0m new_axis\u001b[39m=\u001b[39;49mnew_labels,\n\u001b[1;32m 965\u001b[0m indexer\u001b[39m=\u001b[39;49mindexer,\n\u001b[1;32m 966\u001b[0m axis\u001b[39m=\u001b[39;49maxis,\n\u001b[1;32m 967\u001b[0m allow_dups\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m,\n\u001b[1;32m 968\u001b[0m copy\u001b[39m=\u001b[39;49m\u001b[39mNone\u001b[39;49;00m,\n\u001b[1;32m 969\u001b[0m )\n", - "File \u001b[0;32m~/miniforge3/lib/python3.9/site-packages/pandas/core/internals/managers.py:747\u001b[0m, in \u001b[0;36mBaseBlockManager.reindex_indexer\u001b[0;34m(self, new_axis, indexer, axis, fill_value, allow_dups, copy, only_slice, use_na_proxy)\u001b[0m\n\u001b[1;32m 740\u001b[0m new_blocks \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_slice_take_blocks_ax0(\n\u001b[1;32m 741\u001b[0m indexer,\n\u001b[1;32m 742\u001b[0m fill_value\u001b[39m=\u001b[39mfill_value,\n\u001b[1;32m 743\u001b[0m only_slice\u001b[39m=\u001b[39monly_slice,\n\u001b[1;32m 744\u001b[0m use_na_proxy\u001b[39m=\u001b[39muse_na_proxy,\n\u001b[1;32m 745\u001b[0m )\n\u001b[1;32m 746\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[0;32m--> 747\u001b[0m new_blocks \u001b[39m=\u001b[39m [\n\u001b[1;32m 748\u001b[0m blk\u001b[39m.\u001b[39mtake_nd(\n\u001b[1;32m 749\u001b[0m indexer,\n\u001b[1;32m 750\u001b[0m axis\u001b[39m=\u001b[39m\u001b[39m1\u001b[39m,\n\u001b[1;32m 751\u001b[0m fill_value\u001b[39m=\u001b[39m(\n\u001b[1;32m 752\u001b[0m fill_value \u001b[39mif\u001b[39;00m fill_value \u001b[39mis\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39mNone\u001b[39;00m \u001b[39melse\u001b[39;00m blk\u001b[39m.\u001b[39mfill_value\n\u001b[1;32m 753\u001b[0m ),\n\u001b[1;32m 754\u001b[0m )\n\u001b[1;32m 755\u001b[0m \u001b[39mfor\u001b[39;00m blk \u001b[39min\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mblocks\n\u001b[1;32m 756\u001b[0m ]\n\u001b[1;32m 758\u001b[0m new_axes \u001b[39m=\u001b[39m \u001b[39mlist\u001b[39m(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39maxes)\n\u001b[1;32m 759\u001b[0m new_axes[axis] \u001b[39m=\u001b[39m new_axis\n", - "File \u001b[0;32m~/miniforge3/lib/python3.9/site-packages/pandas/core/internals/managers.py:748\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 740\u001b[0m new_blocks \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_slice_take_blocks_ax0(\n\u001b[1;32m 741\u001b[0m indexer,\n\u001b[1;32m 742\u001b[0m fill_value\u001b[39m=\u001b[39mfill_value,\n\u001b[1;32m 743\u001b[0m only_slice\u001b[39m=\u001b[39monly_slice,\n\u001b[1;32m 744\u001b[0m use_na_proxy\u001b[39m=\u001b[39muse_na_proxy,\n\u001b[1;32m 745\u001b[0m )\n\u001b[1;32m 746\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m 747\u001b[0m new_blocks \u001b[39m=\u001b[39m [\n\u001b[0;32m--> 748\u001b[0m blk\u001b[39m.\u001b[39;49mtake_nd(\n\u001b[1;32m 749\u001b[0m indexer,\n\u001b[1;32m 750\u001b[0m axis\u001b[39m=\u001b[39;49m\u001b[39m1\u001b[39;49m,\n\u001b[1;32m 751\u001b[0m fill_value\u001b[39m=\u001b[39;49m(\n\u001b[1;32m 752\u001b[0m fill_value \u001b[39mif\u001b[39;49;00m fill_value \u001b[39mis\u001b[39;49;00m \u001b[39mnot\u001b[39;49;00m \u001b[39mNone\u001b[39;49;00m \u001b[39melse\u001b[39;49;00m blk\u001b[39m.\u001b[39;49mfill_value\n\u001b[1;32m 753\u001b[0m ),\n\u001b[1;32m 754\u001b[0m )\n\u001b[1;32m 755\u001b[0m \u001b[39mfor\u001b[39;00m blk \u001b[39min\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mblocks\n\u001b[1;32m 756\u001b[0m ]\n\u001b[1;32m 758\u001b[0m new_axes \u001b[39m=\u001b[39m \u001b[39mlist\u001b[39m(\u001b[39mself\u001b[39m\u001b[39m.\u001b[39maxes)\n\u001b[1;32m 759\u001b[0m new_axes[axis] \u001b[39m=\u001b[39m new_axis\n", - "File \u001b[0;32m~/miniforge3/lib/python3.9/site-packages/pandas/core/internals/blocks.py:945\u001b[0m, in \u001b[0;36mBlock.take_nd\u001b[0;34m(self, indexer, axis, new_mgr_locs, fill_value)\u001b[0m\n\u001b[1;32m 942\u001b[0m allow_fill \u001b[39m=\u001b[39m \u001b[39mTrue\u001b[39;00m\n\u001b[1;32m 944\u001b[0m \u001b[39m# Note: algos.take_nd has upcast logic similar to coerce_to_target_dtype\u001b[39;00m\n\u001b[0;32m--> 945\u001b[0m new_values \u001b[39m=\u001b[39m algos\u001b[39m.\u001b[39;49mtake_nd(\n\u001b[1;32m 946\u001b[0m values, indexer, axis\u001b[39m=\u001b[39;49maxis, allow_fill\u001b[39m=\u001b[39;49mallow_fill, fill_value\u001b[39m=\u001b[39;49mfill_value\n\u001b[1;32m 947\u001b[0m )\n\u001b[1;32m 949\u001b[0m \u001b[39m# Called from three places in managers, all of which satisfy\u001b[39;00m\n\u001b[1;32m 950\u001b[0m \u001b[39m# these assertions\u001b[39;00m\n\u001b[1;32m 951\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(\u001b[39mself\u001b[39m, ExtensionBlock):\n\u001b[1;32m 952\u001b[0m \u001b[39m# NB: in this case, the 'axis' kwarg will be ignored in the\u001b[39;00m\n\u001b[1;32m 953\u001b[0m \u001b[39m# algos.take_nd call above.\u001b[39;00m\n", - "File \u001b[0;32m~/miniforge3/lib/python3.9/site-packages/pandas/core/array_algos/take.py:117\u001b[0m, in \u001b[0;36mtake_nd\u001b[0;34m(arr, indexer, axis, fill_value, allow_fill)\u001b[0m\n\u001b[1;32m 114\u001b[0m \u001b[39mreturn\u001b[39;00m arr\u001b[39m.\u001b[39mtake(indexer, fill_value\u001b[39m=\u001b[39mfill_value, allow_fill\u001b[39m=\u001b[39mallow_fill)\n\u001b[1;32m 116\u001b[0m arr \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39masarray(arr)\n\u001b[0;32m--> 117\u001b[0m \u001b[39mreturn\u001b[39;00m _take_nd_ndarray(arr, indexer, axis, fill_value, allow_fill)\n", - "File \u001b[0;32m~/miniforge3/lib/python3.9/site-packages/pandas/core/array_algos/take.py:162\u001b[0m, in \u001b[0;36m_take_nd_ndarray\u001b[0;34m(arr, indexer, axis, fill_value, allow_fill)\u001b[0m\n\u001b[1;32m 157\u001b[0m out \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39mempty(out_shape, dtype\u001b[39m=\u001b[39mdtype)\n\u001b[1;32m 159\u001b[0m func \u001b[39m=\u001b[39m _get_take_nd_function(\n\u001b[1;32m 160\u001b[0m arr\u001b[39m.\u001b[39mndim, arr\u001b[39m.\u001b[39mdtype, out\u001b[39m.\u001b[39mdtype, axis\u001b[39m=\u001b[39maxis, mask_info\u001b[39m=\u001b[39mmask_info\n\u001b[1;32m 161\u001b[0m )\n\u001b[0;32m--> 162\u001b[0m func(arr, indexer, out, fill_value)\n\u001b[1;32m 164\u001b[0m \u001b[39mif\u001b[39;00m flip_order:\n\u001b[1;32m 165\u001b[0m out \u001b[39m=\u001b[39m out\u001b[39m.\u001b[39mT\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] - } - ], - "source": [ - "model.fit(X_train,y_train)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 105, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 2/2 [00:08<00:00, 4.29s/it]" + "Generating Ensemble: 100%|██████████| 10/10 [00:55<00:00, 5.55s/it]\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ - "There are 0.34667% points (416 points) fell out of predictable range.\n" + "Saved! ./test_output/Short-eared_Owl/2020/ensemble_quadtree_df.csv\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "\n" + "training: 100%|██████████| 22091/22091 [03:19<00:00, 110.61it/s]\n" ] } ], "source": [ - "pred_mean, pred_std = model.predict(X_test)\n", - "pred_mean = np.where(pred_mean>0, pred_mean, 0)\n", - "eval_metrics = AdaSTEM.eval_STEM_res('hurdle',y_test, pred_mean)\n", - "eval_metrics" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 106, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "{'AUC': 0.887189289196802,\n", - " 'kappa': 0.6114064535439392,\n", - " 'f1': 0.6284888447294733,\n", - " 'precision': 0.516478622327791,\n", - " 'recall': 0.8025374855824683,\n", - " 'average_precision': 0.42162678825337596,\n", - " 'Spearman_r': 0.6367557741905414,\n", - " 'Pearson_r': 0.4765616063178738,\n", - " 'R2': 0.16306172188722357,\n", - " 'MAE': 0.137857426441832,\n", - " 'MSE': 1.1352335693563165,\n", - " 'poisson_deviance_explained': 0.18587677041254969}" - ] - }, - "execution_count": 106, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 83, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([0., 0., 0., ..., 0., 0., 0.])" - ] - }, - "execution_count": 83, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "y_test" - ] - }, - { - "cell_type": "code", - "execution_count": 88, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(7831, 16194.0)" - ] - }, - "execution_count": 88, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "np.sum(pred_mean>0), np.sum(y_test)" + "model.fit(X_train,y_train)\n", + "\n" ] }, { "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 78, + "execution_count": 48, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'AUC': 0.7444842573492204,\n", - " 'kappa': 0.3522531197225499,\n", - " 'f1': 0.38237711655433176,\n", - " 'precision': 0.29702464563912656,\n", - " 'recall': 0.5365628604382929,\n", - " 'average_precision': 0.17611406015146674,\n", - " 'Spearman_r': 0.3751399926503052,\n", - " 'Pearson_r': 0.1583922499197465,\n", - " 'R2': -0.04986726700839905,\n", - " 'MAE': 0.17384971701010232,\n", - " 'MSE': 1.7822250985874357,\n", - " 'poisson_deviance_explained': -0.04100669489888009}" + "{'AUC': 0.665107390314002,\n", + " 'kappa': 0.11334707386113607,\n", + " 'f1': 0.11591836734693878,\n", + " 'precision': 0.06995073891625615,\n", + " 'recall': 0.3380952380952381,\n", + " 'average_precision': 0.024808345062162798,\n", + " 'Spearman_r': 0.1515292692961601,\n", + " 'Pearson_r': 0.3401933458305159,\n", + " 'R2': 0.08247945821643232,\n", + " 'MAE': 0.0049833325791876016,\n", + " 'MSE': 0.01552479010798023,\n", + " 'poisson_deviance_explained': 0.31046408714351403}" ] }, - "execution_count": 78, + "execution_count": 48, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "eval_metrics = AdaSTEM.eval_STEM_res('hurdle',y_test, pred_mean)\n", + "pred_mean, pred_std = model.predict(X_test)\n", + "pred_mean = np.where(pred_mean>0, pred_mean, 0)\n", + "eval_metrics = AdaSTEM.eval_STEM_res('hurdle',y_test, pred_mean)\n", "eval_metrics\n" ] }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 49, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "predicting ensemble 0 : 100%|██████████| 2175/2175 [00:09<00:00, 241.17it/s]\n", - "predicting ensemble 1 : 100%|██████████| 2909/2909 [00:11<00:00, 254.65it/s]\n" - ] - } - ], + "outputs": [], "source": [ "checklist_data['abundance_pred_mean'], checklist_data['abundance_pred_std'] = model.predict(checklist_data[model.x_names + ['sampling_event_identifier','longitude','latitude']])\n", "\n" @@ -822,60 +680,14 @@ }, { "cell_type": "code", - "execution_count": 72, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.0.0.0.0.1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27.28.29.30.31.32.33.34.35.36.37.38.39.40.41.42.43.44.45.46.47.48.49.50.51.52.53.54.55.56.57.58.59.60.61.62.63.64.65.66.67.68.69.70.71.72.73.74.75.76.77.78.79.80.81.82.83.84.85.86.87.88.89.90.91.92.93.94.95.96.97.98.99.100.101.102.103.104.105.106.107.108.109.110.111.112.113.114.115.116.117.118.119.120.121.122.123.124.125.126.127.128.129.130.131.132.133.134.135.136.137.138.139.140.141.142.143.144.145.146.147.148.149.150.151.152.153.154.155.156.157.158.159.160.161.162.163.164.165.166.167.168.169.170.171.172.173.174.175.176.177.178.179.180.181.182.183.184.185.186.187.188.189.190.191.192.193.194.195.196.197.198.199.200.201.202.203.204.205.206.207.208.209.210.211.212.213.214.215.216.217.218.219.220.221.222.223.224.225.226.227.228.229.230.231.232.233.234.235.236.237.238.239.240.241.242.243.244.245.246.247.248.249.250.251.252.253.254.255.256.257.258.259.260.261.262.263.264.265.266.267.268.269.270.271.272.273.274.275.276.277.278.279.280.281.282.283.284.285.286.287.288.289.290.291.292.293.294.295.296.297.298.299.300.301.302.303.304.305.306.307.308.309.310.311.312.313.314.315.316.317.318.319.320.321.322.323.324.325.326.327.328.329.330.331.332.333.334.335.336.337.338.339.340.341.342.343.344.345.346.347.348.349.350.351.352.353.354.355.356.357.358.359.360.361.362.363.364.365.\n", - "Finish!\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "data_origin = checklist_data[['sampling_event_identifier','longitude','latitude','DOY','count']]\n", - "make_sample_gif(data_origin, os.path.join(SAVE_DIR, 'Sample_data_origin.gif'), col='count', log_scale=True)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 73, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "0.0.0.0.0.1.2.3.4.5.6.7.8.9.10.11.12.13.14.15.16.17.18.19.20.21.22.23.24.25.26.27.28.29.30.31.32.33.34.35.36.37.38.39.40.41.42.43.44.45.46.47.48.49.50.51.52.53.54.55.56.57.58.59.60.61.62.63.64.65.66.67.68.69.70.71.72.73.74.75.76.77.78.79.80.81.82.83.84.85.86.87.88.89.90.91.92.93.94.95.96.97.98.99.100.101.102.103.104.105.106.107.108.109.110.111.112.113.114.115.116.117.118.119.120.121.122.123.124.125.126.127.128.129.130.131.132.133.134.135.136.137.138.139.140.141.142.143.144.145.146.147.148.149.150.151.152.153.154.155.156.157.158.159.160.161.162.163.164.165.166.167.168.169.170.171.172.173.174.175.176.177.178.179.180.181.182.183.184.185.186.187.188.189.190.191.192.193.194.195.196.197.198.199.200.201.202.203.204.205.206.207.208.209.210.211.212.213.214.215.216.217.218.219.220.221.222.223.224.225.226.227.228.229.230.231.232.233.234.235.236.237.238.239.240.241.242.243.244.245.246.247.248.249.250.251.252.253.254.255.256.257.258.259.260.261.262.263.264.265.266.267.268.269.270.271.272.273.274.275.276.277.278.279.280.281.282.283.284.285.286.287.288.289.290.291.292.293.294.295.296.297.298.299.300.301.302.303.304.305.306.307.308.309.310.311.312.313.314.315.316.317.318.319.320.321.322.323.324.325.326.327.328.329.330.331.332.333.334.335.336.337.338.339.340.341.342.343.344.345.346.347.348.349.350.351.352.353.354.355.356.357.358.359.360.361.362.363.364.365.\n", - "Finish!\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "data_pred = checklist_data[['sampling_event_identifier','longitude','latitude','DOY','abundance_pred_mean']]\n", - "make_sample_gif(data_pred , os.path.join(SAVE_DIR, 'Sample_data_pred.gif'), col='abundance_pred_mean', log_scale=True)\n" + "# data_origin = checklist_data[['sampling_event_identifier','longitude','latitude','DOY','count']]\n", + "# make_sample_gif(data_origin, os.path.join(SAVE_DIR, 'Sample_data_origin.gif'), col='count', log_scale=True)\n", + "# data_pred = checklist_data[['sampling_event_identifier','longitude','latitude','DOY','abundance_pred_mean']]\n", + "# make_sample_gif(data_pred , os.path.join(SAVE_DIR, 'Sample_data_pred.gif'), col='abundance_pred_mean', log_scale=True)\n" ] }, { @@ -887,38 +699,16 @@ }, { "cell_type": "code", - "execution_count": 79, + "execution_count": 50, "metadata": {}, - "outputs": [ - { - "ename": "KeyboardInterrupt", - "evalue": "", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyboardInterrupt\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[79], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m pred_set \u001b[39m=\u001b[39m pd\u001b[39m.\u001b[39;49mread_csv(\u001b[39m'\u001b[39;49m\u001b[39m./BirdSTEM/dataset/test_data/prediction_set/prediction_set_gridlen10_2020_ERA_bios.txt\u001b[39;49m\u001b[39m'\u001b[39;49m,sep\u001b[39m=\u001b[39;49m\u001b[39m'\u001b[39;49m\u001b[39m\\t\u001b[39;49;00m\u001b[39m'\u001b[39;49m)\n", - "File \u001b[0;32m~/miniforge3/lib/python3.9/site-packages/pandas/io/parsers/readers.py:912\u001b[0m, in \u001b[0;36mread_csv\u001b[0;34m(filepath_or_buffer, sep, delimiter, header, names, index_col, usecols, dtype, engine, converters, true_values, false_values, skipinitialspace, skiprows, skipfooter, nrows, na_values, keep_default_na, na_filter, verbose, skip_blank_lines, parse_dates, infer_datetime_format, keep_date_col, date_parser, date_format, dayfirst, cache_dates, iterator, chunksize, compression, thousands, decimal, lineterminator, quotechar, quoting, doublequote, escapechar, comment, encoding, encoding_errors, dialect, on_bad_lines, delim_whitespace, low_memory, memory_map, float_precision, storage_options, dtype_backend)\u001b[0m\n\u001b[1;32m 899\u001b[0m kwds_defaults \u001b[39m=\u001b[39m _refine_defaults_read(\n\u001b[1;32m 900\u001b[0m dialect,\n\u001b[1;32m 901\u001b[0m delimiter,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 908\u001b[0m dtype_backend\u001b[39m=\u001b[39mdtype_backend,\n\u001b[1;32m 909\u001b[0m )\n\u001b[1;32m 910\u001b[0m kwds\u001b[39m.\u001b[39mupdate(kwds_defaults)\n\u001b[0;32m--> 912\u001b[0m \u001b[39mreturn\u001b[39;00m _read(filepath_or_buffer, kwds)\n", - "File \u001b[0;32m~/miniforge3/lib/python3.9/site-packages/pandas/io/parsers/readers.py:583\u001b[0m, in \u001b[0;36m_read\u001b[0;34m(filepath_or_buffer, kwds)\u001b[0m\n\u001b[1;32m 580\u001b[0m \u001b[39mreturn\u001b[39;00m parser\n\u001b[1;32m 582\u001b[0m \u001b[39mwith\u001b[39;00m parser:\n\u001b[0;32m--> 583\u001b[0m \u001b[39mreturn\u001b[39;00m parser\u001b[39m.\u001b[39;49mread(nrows)\n", - "File \u001b[0;32m~/miniforge3/lib/python3.9/site-packages/pandas/io/parsers/readers.py:1704\u001b[0m, in \u001b[0;36mTextFileReader.read\u001b[0;34m(self, nrows)\u001b[0m\n\u001b[1;32m 1697\u001b[0m nrows \u001b[39m=\u001b[39m validate_integer(\u001b[39m\"\u001b[39m\u001b[39mnrows\u001b[39m\u001b[39m\"\u001b[39m, nrows)\n\u001b[1;32m 1698\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[1;32m 1699\u001b[0m \u001b[39m# error: \"ParserBase\" has no attribute \"read\"\u001b[39;00m\n\u001b[1;32m 1700\u001b[0m (\n\u001b[1;32m 1701\u001b[0m index,\n\u001b[1;32m 1702\u001b[0m columns,\n\u001b[1;32m 1703\u001b[0m col_dict,\n\u001b[0;32m-> 1704\u001b[0m ) \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_engine\u001b[39m.\u001b[39;49mread( \u001b[39m# type: ignore[attr-defined]\u001b[39;49;00m\n\u001b[1;32m 1705\u001b[0m nrows\n\u001b[1;32m 1706\u001b[0m )\n\u001b[1;32m 1707\u001b[0m \u001b[39mexcept\u001b[39;00m \u001b[39mException\u001b[39;00m:\n\u001b[1;32m 1708\u001b[0m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mclose()\n", - "File \u001b[0;32m~/miniforge3/lib/python3.9/site-packages/pandas/io/parsers/c_parser_wrapper.py:234\u001b[0m, in \u001b[0;36mCParserWrapper.read\u001b[0;34m(self, nrows)\u001b[0m\n\u001b[1;32m 232\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[1;32m 233\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mlow_memory:\n\u001b[0;32m--> 234\u001b[0m chunks \u001b[39m=\u001b[39m \u001b[39mself\u001b[39;49m\u001b[39m.\u001b[39;49m_reader\u001b[39m.\u001b[39;49mread_low_memory(nrows)\n\u001b[1;32m 235\u001b[0m \u001b[39m# destructive to chunks\u001b[39;00m\n\u001b[1;32m 236\u001b[0m data \u001b[39m=\u001b[39m _concatenate_chunks(chunks)\n", - "File \u001b[0;32m~/miniforge3/lib/python3.9/site-packages/pandas/_libs/parsers.pyx:812\u001b[0m, in \u001b[0;36mpandas._libs.parsers.TextReader.read_low_memory\u001b[0;34m()\u001b[0m\n", - "File \u001b[0;32m~/miniforge3/lib/python3.9/site-packages/pandas/_libs/parsers.pyx:889\u001b[0m, in \u001b[0;36mpandas._libs.parsers.TextReader._read_rows\u001b[0;34m()\u001b[0m\n", - "File \u001b[0;32m~/miniforge3/lib/python3.9/site-packages/pandas/_libs/parsers.pyx:1034\u001b[0m, in \u001b[0;36mpandas._libs.parsers.TextReader._convert_column_data\u001b[0;34m()\u001b[0m\n", - "File \u001b[0;32m~/miniforge3/lib/python3.9/site-packages/pandas/_libs/parsers.pyx:1088\u001b[0m, in \u001b[0;36mpandas._libs.parsers.TextReader._convert_tokens\u001b[0;34m()\u001b[0m\n", - "File \u001b[0;32m~/miniforge3/lib/python3.9/site-packages/pandas/_libs/parsers.pyx:1163\u001b[0m, in \u001b[0;36mpandas._libs.parsers.TextReader._convert_with_dtype\u001b[0;34m()\u001b[0m\n", - "File \u001b[0;32m~/miniforge3/lib/python3.9/site-packages/pandas/core/dtypes/common.py:1335\u001b[0m, in \u001b[0;36mis_extension_array_dtype\u001b[0;34m(arr_or_dtype)\u001b[0m\n\u001b[1;32m 1326\u001b[0m \u001b[39m# Note: if other EA dtypes are ever held in HybridBlock, exclude those\u001b[39;00m\n\u001b[1;32m 1327\u001b[0m \u001b[39m# here too.\u001b[39;00m\n\u001b[1;32m 1328\u001b[0m \u001b[39m# NB: need to check DatetimeTZDtype and not is_datetime64tz_dtype\u001b[39;00m\n\u001b[1;32m 1329\u001b[0m \u001b[39m# to exclude ArrowTimestampUSDtype\u001b[39;00m\n\u001b[1;32m 1330\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39misinstance\u001b[39m(dtype, ExtensionDtype) \u001b[39mand\u001b[39;00m \u001b[39mnot\u001b[39;00m \u001b[39misinstance\u001b[39m(\n\u001b[1;32m 1331\u001b[0m dtype, (DatetimeTZDtype, PeriodDtype)\n\u001b[1;32m 1332\u001b[0m )\n\u001b[0;32m-> 1335\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mis_extension_array_dtype\u001b[39m(arr_or_dtype) \u001b[39m-\u001b[39m\u001b[39m>\u001b[39m \u001b[39mbool\u001b[39m:\n\u001b[1;32m 1336\u001b[0m \u001b[39m \u001b[39m\u001b[39m\"\"\"\u001b[39;00m\n\u001b[1;32m 1337\u001b[0m \u001b[39m Check if an object is a pandas extension array type.\u001b[39;00m\n\u001b[1;32m 1338\u001b[0m \n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 1378\u001b[0m \u001b[39m False\u001b[39;00m\n\u001b[1;32m 1379\u001b[0m \u001b[39m \"\"\"\u001b[39;00m\n\u001b[1;32m 1380\u001b[0m dtype \u001b[39m=\u001b[39m \u001b[39mgetattr\u001b[39m(arr_or_dtype, \u001b[39m\"\u001b[39m\u001b[39mdtype\u001b[39m\u001b[39m\"\u001b[39m, arr_or_dtype)\n", - "\u001b[0;31mKeyboardInterrupt\u001b[0m: " - ] - } - ], + "outputs": [], "source": [ "pred_set = pd.read_csv('./BirdSTEM/dataset/test_data/prediction_set/prediction_set_gridlen10_2020_ERA_bios.txt',sep='\\t')\n" ] }, { "cell_type": "code", - "execution_count": 340, + "execution_count": 51, "metadata": {}, "outputs": [], "source": [ @@ -936,7 +726,7 @@ }, { "cell_type": "code", - "execution_count": 341, + "execution_count": 52, "metadata": {}, "outputs": [], "source": [ @@ -952,7 +742,7 @@ }, { "cell_type": "code", - "execution_count": 342, + "execution_count": 53, "metadata": {}, "outputs": [], "source": [ @@ -966,12 +756,13 @@ " np.arange(pred_set.latitude.min(), pred_set.latitude.max(), 1) ## 1 sample per degree(~110 km)\n", ")\n", "\n", - "reduced_pred_set = pred_set.sample(frac=1, replace=False).groupby(['lng_grid','lat_grid']).first().reset_index(drop=True)" + "reduced_pred_set = pred_set.sample(frac=1, replace=False).groupby(['lng_grid','lat_grid']).first().reset_index(drop=True)\n", + "\n" ] }, { "cell_type": "code", - "execution_count": 343, + "execution_count": 54, "metadata": {}, "outputs": [], "source": [ @@ -980,13 +771,13 @@ }, { "cell_type": "code", - "execution_count": 379, + "execution_count": 55, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "79da075fa3e6446c89e162c7dac2e13d", + "model_id": "b3e6d661ac924711b1b9b767361d8360", "version_major": 2, "version_minor": 0 }, @@ -1018,25 +809,45 @@ }, { "cell_type": "code", - "execution_count": 381, + "execution_count": 56, "metadata": {}, "outputs": [], "source": [ - "pred_whole_year = pd.concat(res_list, axis=0)" + "pred_whole_year = pd.concat(res_list, axis=0)\n" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "pred_whole_year.to_csv(os.path.join(SAVE_DIR, 'pred_whole_year.csv'), index=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 58, "metadata": {}, "outputs": [], "source": [ - "pred_whole_year.to_csv(os.path.join(SAVE_DIR, 'pred_whole_year.csv'), index=False)" + "# make_sample_gif(pred_whole_year , \n", + "# os.path.join(SAVE_DIR, 'Sample_prediction_results_pixel.gif'),\n", + "# col='pred_mean', log_scale=True, dpi=200, fps=30)\n" ] }, { "cell_type": "code", - "execution_count": 389, + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "pred_whole_year['pred_mean_absolute'] = np.where(pred_whole_year['pred_mean']<0, 0, pred_whole_year['pred_mean'])" + ] + }, + { + "cell_type": "code", + "execution_count": 60, "metadata": {}, "outputs": [ { @@ -1049,7 +860,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1060,26 +871,14 @@ ], "source": [ "make_sample_gif_hexagon(pred_whole_year , os.path.join(SAVE_DIR, 'Sample_prediction_results.gif'), \n", - " col='pred_mean', log_scale=True, dpi=200, fps=30)\n" + " col='pred_mean_absolute', log_scale=True, dpi=100, fps=30)\n" ] }, { "cell_type": "code", - "execution_count": 394, + "execution_count": 61, "metadata": {}, - "outputs": [ - { - "ename": "PicklingError", - "evalue": "Can't pickle : it's not the same object as BirdSTEM.model.AdaSTEM.AdaSTEMHurdle", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mPicklingError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[394], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[39mwith\u001b[39;00m \u001b[39mopen\u001b[39m(\u001b[39m'\u001b[39m\u001b[39m./Sample_model.pkl\u001b[39m\u001b[39m'\u001b[39m,\u001b[39m'\u001b[39m\u001b[39mwb\u001b[39m\u001b[39m'\u001b[39m) \u001b[39mas\u001b[39;00m f:\n\u001b[0;32m----> 2\u001b[0m pickle\u001b[39m.\u001b[39;49mdump(model, f)\n", - "\u001b[0;31mPicklingError\u001b[0m: Can't pickle : it's not the same object as BirdSTEM.model.AdaSTEM.AdaSTEMHurdle" - ] - } - ], + "outputs": [], "source": [ "with open(os.path.join(SAVE_DIR, 'Sample_model.pkl'), 'wb') as f:\n", " pickle.dump(model, f)\n", @@ -1095,7 +894,7 @@ }, { "cell_type": "code", - "execution_count": 56, + "execution_count": 62, "metadata": {}, "outputs": [], "source": [ @@ -1107,7 +906,7 @@ }, { "cell_type": "code", - "execution_count": 57, + "execution_count": 63, "metadata": {}, "outputs": [], "source": [ @@ -1123,27 +922,27 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 64, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "{'AUC': 0.9394320670436354,\n", - " 'kappa': 0.5390257017207126,\n", - " 'f1': 0.5622691476757962,\n", - " 'precision': 0.4028360295586179,\n", - " 'recall': 0.9305651672433679,\n", - " 'average_precision': 0.3773735105512029,\n", - " 'Spearman_r': 0.5964785441750928,\n", - " 'Pearson_r': 0.4438481758562378,\n", - " 'R2': 0.015957821712900944,\n", - " 'MAE': 0.23321927451116112,\n", - " 'MSE': 1.6704822822120522,\n", - " 'poisson_deviance_explained': -0.07295446082249613}" + "{'AUC': 0.6415172981288684,\n", + " 'kappa': 0.2012434147098403,\n", + " 'f1': 0.20304568527918782,\n", + " 'precision': 0.15748031496062992,\n", + " 'recall': 0.2857142857142857,\n", + " 'average_precision': 0.04624437570303712,\n", + " 'Spearman_r': 0.21017326366742548,\n", + " 'Pearson_r': 0.23544800512235547,\n", + " 'R2': -0.8745137697394276,\n", + " 'MAE': 0.009009192776307464,\n", + " 'MSE': 0.031717472802465146,\n", + " 'poisson_deviance_explained': -0.8736637022227636}" ] }, - "execution_count": 58, + "execution_count": 64, "metadata": {}, "output_type": "execute_result" } @@ -1152,6 +951,112 @@ "AdaSTEM.eval_STEM_res('hurdle', y_test, baseline_pred.flatten())" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [], + "source": [ + "stds = np.random.uniform(0, 1, size=1000)\n", + "means = np.random.lognormal(0, 1, size=1000)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 121, + "metadata": {}, + "outputs": [], + "source": [ + "trasnformed_means = np.log(means)\n", + "transformed_stds =np.sqrt((means**2) * (np.e ** (stds ** 2) - 1))" + ] + }, + { + "cell_type": "code", + "execution_count": 122, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_dist(means, stds):\n", + " from scipy.stats import norm\n", + " lower = means - 2* stds\n", + " upper = means + 2* stds\n", + " for m, s, l, u in zip(means, stds, lower, upper):\n", + " x = np.linspace(l, u, 100)\n", + " y = norm.pdf(x, loc=m, scale=s)\n", + " plt.plot(x,y)" + ] + }, + { + "cell_type": "code", + "execution_count": 127, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 127, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(stds, transformed_stds)\n", + "# plt.ylim(0,1)" + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_dist(trasnformed_means, transformed_stds)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, { "cell_type": "code", "execution_count": null,