bleugh

Author: Ciaran1981

geolearn_env.yml

@@ -41,14 +41,14 @@ dependencies:
   - optuna
   - plotly
   - openpyxl
+  - skorch
 
   - pip:
     - morphsnakes
     - xmltodict
     - simpledbf
     - pyfftw
     - phasepack
-
     - SimpleCRF
     - git+https://github.com/Ciaran1981/geospatial-learn#egg=geospatial-learn
 #py

geospatial_learn/convutils.py

@@ -14,26 +14,24 @@
 import numpy as np
 from skimage.exposure import rescale_intensity 
 import os
-from glob2 import glob
+from glob import glob
 import matplotlib.pyplot as plt
 # Albumentations
 from collections import defaultdict
 import copy
 import random
 import albumentations as A
 from albumentations.pytorch import ToTensorV2
-import ternausnet.models
 from tqdm import tqdm
 import torch
 import torch.backends.cudnn as cudnn
 import torch.nn as nn
 import torch.optim
 from torch.utils.data import Dataset, DataLoader
 from torchvision.models import segmentation
-import gdal
+from osgeo import gdal
 import segmentation_models_pytorch as smp
 import skimage.morphology as skm
-import gdal
 import pandas as pd
 from mpl_toolkits.axes_grid1 import ImageGrid
 gdal.UseExceptions()
@@ -472,51 +470,43 @@ def create_model(params, activation, proc="cuda:0"):
 
     device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 
-    if params["model"] == "UNet11" or params["model"] == "UNet16":
-        model = getattr(ternausnet.models, params["model"])(pretrained=True)
-        if torch.cuda.device_count() > 1: 
-            #consider also DistributedDataParallel
-            model= nn.DataParallel(model)
-        hrdWare = torch.device(proc)
-        model = model.to(hrdWare)
-        
+
+    #Unet,  UNet16, ULinknet, FPN, PSPNet,PAN, DeepLabV3 and DeepLabV3+
+    if params["model"] == 'Unet':
+        model = smp.Unet(encoder_name=params['encoder'], 
+                    classes=params['classes'],in_channels=params['in_channels'],
+                    activation=activation)     
+    if params["model"] == 'Linknet':
+        model = smp.Linknet(encoder_name=params['encoder'], 
+                    classes=params['classes'],in_channels=params['in_channels'],
+                    activation=activation) 
+    if params["model"] == 'FPN':
+        model = smp.FPN(encoder_name=params['encoder'], 
+                    classes=params['classes'],in_channels=params['in_channels'],
+                    activation=activation) 
+    if params["model"] == 'PSPNet':
+        model = smp.PSPNet(encoder_name=params['encoder'], 
+                    classes=params['classes'],in_channels=params['in_channels'],
+                    activation=activation) 
+    if params["model"] == 'PAN':
+        model = smp.PAN(encoder_name=params['encoder'], 
+                    classes=params['classes'],in_channels=params['in_channels'],
+                    activation=activation) 
+    if params["model"] == 'DeepLabV3':
+        model = smp.DeepLabV3(encoder_name=params['encoder'], 
+                    classes=params['classes'],in_channels=params['in_channels'],
+                    activation=activation) 
+    if params["model"] == 'DeepLabV3+':
+        model = smp.DeepLabV3(encoder_name=params['encoder'], 
+                    classes=params['classes'],in_channels=params['in_channels'],
+                    activation=activation)
+    if torch.cuda.device_count() > 1: 
+        #consider also DistributedDataParallel
+        model= nn.DataParallel(model)
+        model = model.to(device)
     else:
-        #Unet,  UNet16, ULinknet, FPN, PSPNet,PAN, DeepLabV3 and DeepLabV3+
-        if params["model"] == 'Unet':
-            model = smp.Unet(encoder_name=params['encoder'], 
-                        classes=params['classes'],in_channels=params['in_channels'],
-                        activation=activation)     
-        if params["model"] == 'Linknet':
-            model = smp.Linknet(encoder_name=params['encoder'], 
-                        classes=params['classes'],in_channels=params['in_channels'],
-                        activation=activation) 
-        if params["model"] == 'FPN':
-            model = smp.FPN(encoder_name=params['encoder'], 
-                        classes=params['classes'],in_channels=params['in_channels'],
-                        activation=activation) 
-        if params["model"] == 'PSPNet':
-            model = smp.PSPNet(encoder_name=params['encoder'], 
-                        classes=params['classes'],in_channels=params['in_channels'],
-                        activation=activation) 
-        if params["model"] == 'PAN':
-            model = smp.PAN(encoder_name=params['encoder'], 
-                        classes=params['classes'],in_channels=params['in_channels'],
-                        activation=activation) 
-        if params["model"] == 'DeepLabV3':
-            model = smp.DeepLabV3(encoder_name=params['encoder'], 
-                        classes=params['classes'],in_channels=params['in_channels'],
-                        activation=activation) 
-        if params["model"] == 'DeepLabV3+':
-            model = smp.DeepLabV3(encoder_name=params['encoder'], 
-                        classes=params['classes'],in_channels=params['in_channels'],
-                        activation=activation)
-        if torch.cuda.device_count() > 1: 
-            #consider also DistributedDataParallel
-            model= nn.DataParallel(model)
-            model = model.to(device)
-        else:
-            hrdWare = torch.device(proc)
-            model = model.to(hrdWare)        
+        hrdWare = torch.device(proc)
+        model = model.to(hrdWare)        
 
     return model
 

geospatial_learn/learning.py

@@ -27,7 +27,9 @@
 import numpy as np
 from sklearn.pipeline import Pipeline
 from sklearn.model_selection import (StratifiedKFold, GroupKFold, KFold, 
-                                     train_test_split,GroupShuffleSplit, PredefinedSplit)
+                                     train_test_split,GroupShuffleSplit,
+                                     StratifiedGroupKFold, 
+                                     PredefinedSplit)
 from sklearn.ensemble import (RandomForestClassifier, ExtraTreesClassifier,
                               GradientBoostingClassifier,RandomForestRegressor,
                               GradientBoostingRegressor, ExtraTreesRegressor,
@@ -39,6 +41,7 @@
 from sklearn.preprocessing import (LabelEncoder, MaxAbsScaler, MinMaxScaler,
                                    Normalizer, PowerTransformer,StandardScaler,
                                    QuantileTransformer)
+from sklearn.svm import SVC, SVR, NuSVC, NuSVR, LinearSVC, LinearSVR
 from sklearn.feature_selection import VarianceThreshold, RFECV
 from sklearn.inspection import permutation_importance
 from sklearn import metrics
@@ -256,7 +259,7 @@ def objective(trial, X, y, cv, group, score=scr):
     print(f"\tBest value (rmse or r2): {study.best_value:.5f}")
     print(f"\tBest params:")
 
-def _group_cv(X_train, y_train, group, test_size=0.2, cv=10):
+def _group_cv(X_train, y_train, group, test_size=0.2, cv=10, strat=False):
 
     """
     Return the splits and and vars for a group grid search
@@ -275,17 +278,27 @@ def _group_cv(X_train, y_train, group, test_size=0.2, cv=10):
     y_train = y_train[train_inds]
     group_trn = group[train_inds]
 
-    group_kfold = GroupKFold(n_splits=cv) 
-    # Create a nested list of train and test indices for each fold
-    k_kfold = group_kfold.split(X_train, y_train, group_trn)  
+    if strat == True:
+        group_kfold = StratifiedGroupKFold(n_splits=cv).split(X_train,
+                                                              y_train,
+                                                              group_trn)
+    else:
+        group_kfold = GroupKFold(n_splits=cv).split(X_train,
+                                                    y_train,
+                                                    group_trn) 
+    
+    # all this not required produces same as above - keep for ref though
+    # # Create a nested list of train and test indices for each fold
+    # k_kfold = group_kfold.split(X_train, y_train, groups=group_trn)  
 
-    train_ind2, test_ind2 = [list(traintest) for traintest in zip(*k_kfold)]
+    # train_ind2, test_ind2 = [list(traintest) for traintest in zip(*k_kfold)]
 
-    cv = [*zip(train_ind2, test_ind2)]
+    # cv = [*zip(train_ind2, test_ind2)]
 
-    return X_train, y_train, X_test, y_test, cv
+    return X_train, y_train, X_test, y_test, group_kfold
 
-def rec_feat_sel(X_train, featnames, preproc=('scaler', None),  clf='erf',  group=None, 
+def rec_feat_sel(X_train, featnames, preproc=('scaler', None),  clf='erf',  
+                 group=None, 
                  cv=5, params=None, cores=-1, strat=True, 
                  test_size=0.3, regress=False, return_test=True,
                  scoring=None, class_names=None, save=True, cat_feat=None):
@@ -550,7 +563,10 @@ class names in order of their numercial equivalents
                #                            devices='0:1'),
                'lgbm': lgb.LGBMClassifier(random_state=0),
 
-                'hgb': HistGradientBoostingClassifier(random_state=0)}
+                'hgb': HistGradientBoostingClassifier(random_state=0),
+                'svm': SVC(),
+                'nusvc': NuSVC(),
+                'linsvc': LinearSVC()}
 
     regdict = {'rf': RandomForestRegressor(random_state=0),
                'erf': ExtraTreesRegressor(random_state=0),
@@ -563,16 +579,19 @@ class names in order of their numercial equivalents
                #                            task_type="GPU",
                #                            devices='0:1'),
                'lgbm': lgb.LGBMRegressor(random_state=0),
-
-               'hgb': HistGradientBoostingRegressor(random_state=0)}
+               'hgb': HistGradientBoostingRegressor(random_state=0),
+                'svm': SVR(),
+                'nusvc': NuSVR(),
+                'linsvc': LinearSVR()}
 
     if regress is True:
         model = regdict[clf]
         if scoring is None:
             scoring = 'r2'
     else:
         model = clfdict[clf]
-        cv = StratifiedKFold(cv)
+        if group is None:
+            cv = StratifiedKFold(cv)
         if scoring is None:
             scoring = 'accuracy'
 
@@ -600,25 +619,18 @@ class names in order of their numercial equivalents
 
 
     # this is not a good way to do this
-    if group is not None:
+    if regress == True:
+        strat = False # failsafe
 
+    if group is not None: # becoming a mess
+
         X_train, y_train, X_test, y_test, cv = _group_cv(X_train, y_train,
-                                                         group, test_size,
-                                                         cv)
-        
+                                                             group, test_size,
+                                                             cv, strat=strat)        
     else:
         X_train, X_test, y_train, y_test = train_test_split(
             X_train, y_train, test_size=test_size, random_state=0)
-    
-    # 
-    # if clf[0:4] == 'catb':
-    #     # Quick and quiet but can't enter the group cv indices or the sklearn
-    #     # pipe
-    #     ds = Pool(X_train, label=y_train)
-        
-    #     # fails at end saying 
-    #     model.grid_search(param_grid, ds, cv=k_kfold) 
-        #CatBoostError: /src/catboost/catboost/private/libs/options/cross_validation_params.cpp:21: FoldCount is 0
+        #cv = StratifiedKFold(cv)
 
 
     if pipe == 'default':
@@ -650,10 +662,8 @@ class names in order of their numercial equivalents
         grid = GridSearchCV(sk_pipe,  param_grid=sclr, 
                                     cv=cv, n_jobs=cores,
                                     scoring=scoring, verbose=1)
-    
 
-        
-    
+
     grid.fit(X_train, y_train)
 
     joblib.dump(grid.best_estimator_, outModel) 
@@ -667,12 +677,17 @@ class names in order of their numercial equivalents
     else:
         crDf = hp.plot_classif_report(y_test, testresult, target_names=class_names,
                                       save=outModel[:-3]+'._classif_report.png')
+        
+        confmat = metrics.confusion_matrix(testresult, y_test, labels=class_names)
+        disp = metrics.ConfusionMatrixDisplay(confusion_matrix=confmat,
+                                      display_labels=class_names)
+        disp.plot()
 
-        confmat = hp.plt_confmat(X_test, y_test, grid.best_estimator_, 
-                                 class_names=class_names, 
-                                 cmap=plt.cm.Blues, 
-                                 fmt="%d", 
-                                 save=outModel[:-3]+'_confmat.png')
+        # confmat = hp.plt_confmat(X_test, y_test, grid.best_estimator_, 
+        #                          class_names=class_names, 
+        #                          cmap=plt.cm.Blues, 
+        #                          fmt="%d", 
+        #                          save=outModel[:-3]+'_confmat.png')
 
         results = [grid, crDf, confmat]
 
@@ -776,13 +791,26 @@ class names in order of their numercial equivalents
         # we only wish to predict really - but  necessary 
         # for sklearn model construct
     else:
-        clfdict = {'rf': RandomForestClassifier, 'erf': ExtraTreesClassifier,
-                   'gb': GradientBoostingClassifier, 'xgb': XGBClassifier,
-                   'logit': LogisticRegression, 'hgb': HistGradientBoostingClassifier}
-    
-        regdict = {'rf': RandomForestRegressor, 'erf': ExtraTreesRegressor,
-                   'gb': GradientBoostingRegressor, 'xgb': XGBRegressor,
-                    'hgb': HistGradientBoostingRegressor}
+        clfdict = {'rf': RandomForestClassifier(random_state=0),
+                   'erf': ExtraTreesClassifier(random_state=0),
+                   'gb': GradientBoostingClassifier(random_state=0),
+                   'xgb': XGBClassifier(random_state=0),
+                   'logit': LogisticRegression(),
+                   'lgbm': lgb.LGBMClassifier(random_state=0),
+                    'hgb': HistGradientBoostingClassifier(random_state=0),
+                    'svm': SVC(),
+                    'nusvc': NuSVC(),
+                    'linsvc': LinearSVC()}
+        
+        regdict = {'rf': RandomForestRegressor(random_state=0),
+                   'erf': ExtraTreesRegressor(random_state=0),
+                   'gb': GradientBoostingRegressor(random_state=0),
+                   'xgb': XGBRegressor(random_state=0),
+                   'lgbm': lgb.LGBMRegressor(random_state=0),
+                   'hgb': HistGradientBoostingRegressor(random_state=0),
+                    'svm': SVR(),
+                    'nusvc': NuSVR(),
+                    'linsvc': LinearSVR()}
 
         if mtype == 'regress':
             # won't accept the dict even with the ** to unpack it
@@ -840,23 +868,18 @@ def regression_results(y_true, y_pred):
     print('r2: ', round(r2,4))
     print('MAE: ', round(mean_absolute_error,4))
     print('MSE: ', round(mse,4))
+    print('MedianAE', round(median_absolute_error, 4))
     print('RMSE: ', round(np.sqrt(mse),4))   
-#TODO add when sklearn updated    
-    # display = metrics.PredictionErrorDisplay.from_predictions(
-    #     y_true=y,
-    #     y_pred=y_pred,
-    #     kind="actual_vs_predicted",
-    #     ax=ax,
-    #     scatter_kwargs={"alpha": 0.2, "color": "tab:blue"},
-    #     line_kwargs={"color": "tab:red"},
-    # )
-    # print(grid.best_params_)
-    # print(grid.best_estimator_)
-    # print(grid.oob_score_)
-    
-    # plt.plot(est_range, grid_mean_scores)
-    # plt.xlabel('no of estimators')
-    # plt.ylabel('Cross validated accuracy')    
+    #TODO add when sklearn updated    
+    display = metrics.PredictionErrorDisplay.from_predictions(
+        y_true=y_true,
+        y_pred=y_pred,
+        kind="actual_vs_predicted",
+        #ax=ax,
+        scatter_kwargs={"alpha": 0.2, "color": "tab:blue"},
+        line_kwargs={"color": "tab:red"},
+    )
+
 
 
 def RF_oob_opt(model, X_train, min_est, max_est, step, group=None,
@@ -1103,6 +1126,11 @@ def plot_feat_importance_permutation(modelPth, featureNames,  X_test, y_test,
     featureNames : list of strings
                    a list of feature names
     
+    Returns
+    -------
+    
+    pandas df of importances
+    
     """
 
     if modelPth is not str: