def get_theta(self, N=1000): """Remove reference temps from temps """ Tref = np.divide( self.deltaT * (np.exp(self.zc / N) - np.exp(-self.H / N)), (1 - np.exp(-self.H / N))) THETA = ma.subtract(self.mnc('Tav.nc', 'THETA', mask=self.HFacC[:]), np.tile(Tref, (self.Nx, self.Ny, 1)).T) return THETA
def calculate_stl_size(stl, order): try: from numpy.ma import subtract mesh_file = create_mesh(stl) size = subtract(mesh_file.max_, mesh_file.min_) order.width = size[0].item() order.depth = size[1].item() order.height = size[2].item() order.save() except: logger.error('Could not calculate mesh size. Please check your numpy and matplotlib installation')
def focus(self): """ Gets the pose to start at (0,0) and have dimensions as big as needed """ mins = ma.min(self.body.data, axis=(0, 1, 2)) maxs = ma.max(self.body.data, axis=(0, 1, 2)) if np.count_nonzero( mins ) > 0: # Only translate if there is a number to translate by self.body.data = ma.subtract(self.body.data, mins) dimensions = (maxs - mins).tolist() self.header.dimensions = PoseHeaderDimensions(*dimensions)
def runLogisticRegression(self): diff = 1 while diff > 0.01: permutation = np.random.permutation(self.N) newWeights = self.w.copy() for i in permutation: x, y = self.trainingData[i] gradient = divide( multiply(-1.0, multiply(x, y)), (1.0 + exp(multiply(y, np.dot(transpose(self.w), x))))) newWeights = subtract(newWeights, multiply(self.learningRate, gradient)) self.epoch += 1 diff = norm(self.w - newWeights) self.w = newWeights
def main(): #file1, file2 = sys.argv[1:1 + 2] file1 = "/Users/kreitzem/Desktop/scrabble/WWF_layout.png" file2 = "/Users/kreitzem/Desktop/scrabble/WWF_tiles.png" # read images as 2D arrays (convert to grayscale for simplicity) #img1 = imread(file1) img1 = (imread(file1).astype(float)) img2 = (imread(file2).astype(float)) print img1.shape, img2.shape print img1.dtype, img2.dtype #x = (img2.shape[0]-img1.shape[0])/2 #y = (img2.shape[1]-img1.shape[1])/2 #img2 = img2[x:-x, y:-y] print img1.shape, img2.shape img3 = subtract(img2, img1) #plt.imshow(img3) plt.imsave('boo.png', img3)
def test_testArithmetic(self): # Test of basic arithmetic. (x, y, a10, m1, m2, xm, ym, z, zm, xf, s) = self.d a2d = array([[1, 2], [0, 4]]) a2dm = masked_array(a2d, [[0, 0], [1, 0]]) assert_(eq(a2d * a2d, a2d * a2dm)) assert_(eq(a2d + a2d, a2d + a2dm)) assert_(eq(a2d - a2d, a2d - a2dm)) for s in [(12,), (4, 3), (2, 6)]: x = x.reshape(s) y = y.reshape(s) xm = xm.reshape(s) ym = ym.reshape(s) xf = xf.reshape(s) assert_(eq(-x, -xm)) assert_(eq(x + y, xm + ym)) assert_(eq(x - y, xm - ym)) assert_(eq(x * y, xm * ym)) with np.errstate(divide='ignore', invalid='ignore'): assert_(eq(x / y, xm / ym)) assert_(eq(a10 + y, a10 + ym)) assert_(eq(a10 - y, a10 - ym)) assert_(eq(a10 * y, a10 * ym)) with np.errstate(divide='ignore', invalid='ignore'): assert_(eq(a10 / y, a10 / ym)) assert_(eq(x + a10, xm + a10)) assert_(eq(x - a10, xm - a10)) assert_(eq(x * a10, xm * a10)) assert_(eq(x / a10, xm / a10)) assert_(eq(x ** 2, xm ** 2)) assert_(eq(abs(x) ** 2.5, abs(xm) ** 2.5)) assert_(eq(x ** y, xm ** ym)) assert_(eq(np.add(x, y), add(xm, ym))) assert_(eq(np.subtract(x, y), subtract(xm, ym))) assert_(eq(np.multiply(x, y), multiply(xm, ym))) with np.errstate(divide='ignore', invalid='ignore'): assert_(eq(np.divide(x, y), divide(xm, ym)))
def transformX(self, x): z = [1] for kMean in self.kMeans: z.append(exp((-self.gamma) * (norm(subtract(x,kMean)))**2)) return z
def validationExterne(): """ Permet d'effectuer une validation externe entre l'image résultante de la réduction d'échelle et une image de température de surface calculée à partir des bandes 10 et 11 de Landsat 8 (disponibles sur EarthData). Les résultats de la validation externe sont des métriques de qualité en comparant les résultats de la réduction d'échelle à la température de surface calculée à 100m. Ces résultats sont présentés dans la console par des 'print' (lignes 129 à 144). """ # Match prediction result extent landsat_b10 = Image( r'data/LC08_L1TP_014028_20200706_20200721_01_T1_B10.TIF') landsat_b10.reprojectMatch( r'data/MOD11_L2.clipped_test2.tif'.split(".")[0] + '_subdivided_100m.tif', False) landsat_b10.setNewFile( landsat_b10.filename.replace(".TIF", "_reproject.tif")) # Get TOA radiance b10_array = landsat_b10.getArray(masked=True, lower_valid_range=1, upper_valid_range=65535) b10_array_radiance = ma.add(ma.multiply(b10_array, 0.00033420), 0.10000) # Get Brightness Temperature b10_array_brightness_temp = (1321.0789 / (ma.log( (774.8853 / b10_array_radiance) + 1))) - 273.15 # Get NDVI landsat_b4 = Image( r'data/LC08_L1TP_014028_20200706_20200721_01_T1_B4_reproject.tif') b4_DN = landsat_b4.getArray(masked=True, lower_valid_range=1, upper_valid_range=65535) b4 = np.add(np.multiply(b4_DN, float(0.00002)), float(-0.10)) landsat_b5 = Image( r'data/LC08_L1TP_014028_20200706_20200721_01_T1_B5_reproject.tif') b5_DN = landsat_b5.getArray(masked=True, lower_valid_range=1, upper_valid_range=65535) b5 = np.add(np.multiply(b5_DN, float(0.00002)), float(-0.10)) ndvi = np.divide(np.subtract(b5, b4), np.add(b5, b4), where=((np.add(b5, b4)) != 0)) # Get proportion of vegetation min_ndvi = ma.amin(ndvi) max_ndvi = ma.amax(ndvi) pv = ma.power( ma.divide(ma.subtract(ndvi, min_ndvi), (ma.subtract(max_ndvi, min_ndvi)), where=(ma.subtract(max_ndvi, min_ndvi)) != 0), 2) # Get emissivity emissivity = 0.004 * pv + 0.986 # Get Landsat 8 LST landsat_lst = b10_array_brightness_temp / ( 1 + (0.00115 * b10_array_brightness_temp / 1.4388) * ma.log(emissivity)) # Save LST image for visualization landsat_b10.save_band(landsat_lst, r'data/landsat_lst.tif') # Validation between both arrays predicted_lst = ma.masked_invalid( Image(r'data/MODIS_predit_100m.tif').getArray()) predicted_lst_with_residuals = ma.masked_invalid( Image(r'data/MODIS_predit_100m_avec_residus.tif').getArray()) predicted_lst = ma.filled(predicted_lst, 0) predicted_lst_with_residuals = ma.filled(predicted_lst_with_residuals, 0) # Without residuals print('Without residual correction') print('Mean Absolute Error (MAE):', metrics.mean_absolute_error(predicted_lst, landsat_lst)) print('Mean Squared Error:', metrics.mean_squared_error(predicted_lst, landsat_lst)) print('Root Mean Squared Error:', np.sqrt(metrics.mean_squared_error(predicted_lst, landsat_lst)), "°C") print( 'Accuracy:', 100 - np.mean(100 * ((abs(predicted_lst - landsat_lst)) / landsat_lst)), "%") print('Explained variance score (EVS):', metrics.explained_variance_score(predicted_lst, landsat_lst)) # With residuals print("\n") print('With residual correction') print( 'Mean Absolute Error (MAE):', metrics.mean_absolute_error(predicted_lst_with_residuals, landsat_lst)) print( 'Mean Squared Error:', metrics.mean_squared_error(predicted_lst_with_residuals, landsat_lst)) print( 'Root Mean Squared Error:', np.sqrt( metrics.mean_squared_error(predicted_lst_with_residuals, landsat_lst)), "°C") print( 'Accuracy:', 100 - np.mean(100 * ( (abs(predicted_lst_with_residuals - landsat_lst)) / landsat_lst)), "%") print( 'Explained variance score (EVS):', metrics.explained_variance_score(predicted_lst_with_residuals, landsat_lst))
def applyDownscaling(self, predictors, outputFile, residualCorrection=False, outputFile_withResidualCorrection=None, targetResolution=None): """ Entraîne un modèle de Random Forest Regression avec certains prédicteurs spécifiés dans une liste en entrée et applique par la suite la réduction d'échelle avec le modèle entraîné. Le résultat est sauvegardé dans une nouvelle image. Args: predictors (list): Liste de string des prédicteurs à inclure dans l'entraînement ou la prédiction de la réduction d'échelle. Cet argument doit prendre la forme suivante: ['NDVI', 'NDWI', 'NDBI', 'MNT', 'Pente'] avec des prédicteurs disponibles dans cette méthode. outputFile (string): Path vers le fichier dans lequel on souhaite sauvegarder le résultat de la réduction d'échelle à 100m. """ dataframe = self.secteur.getDf( predictors, train=True) # on va cherche le Pandas DataFrame du secteur dataframe = dataframe.replace(-9999.0, np.nan) dataframe = dataframe.dropna() predicteurs = dataframe.drop( 'LST', axis=1 ) # on retire la température de surface (LST) du DataFrame pour ne # conserver que les prédicteurs #predicteurs = predicteurs.dropna() # pour l'entraînement, on retire les valeurs Nulles modis_LST = dataframe['LST'] #modis_LST = modis_LST.dropna() # pour l'entraînement, on retire les valeurs Nulles modis_LST = modis_LST.ravel( ) # format accepté par le Random Forest Regression pour la variable dépendante Y # (une seule ligne) # Split de l'échantillon d'entraînement et de l'échantillon de test (échantillon de test = 25% de l'échantillon # total) test_sample_size = 0.25 X_train, X_test, y_train, y_test = train_test_split( predicteurs, modis_LST, test_size=test_sample_size, random_state=42) # Initialisation du régresseur avec 100 estimateurs regressor = RandomForestRegressor(n_estimators=100, random_state=42) # Entraînement du modèle regressor.fit(X_train, y_train) # ----------- Validation interne --------------- # Prédiction avec l'échantillon de test y_pred = regressor.predict(X_test) # Métriques de qualité sur le résultat prédit par rapport à l'échantillon de test (vérité) print("\n") print("Validation interne avec {}% des échantillons".format( test_sample_size * 100)) print('Coefficient of determination (R2):', metrics.r2_score(y_test, y_pred)) print('Mean Absolute Error (MAE):', metrics.mean_absolute_error(y_test, y_pred)) print('Mean Squared Error:', metrics.mean_squared_error(y_test, y_pred)) print('Root Mean Squared Error:', np.sqrt(metrics.mean_squared_error(y_test, y_pred))) print('Accuracy:', 100 - np.mean(100 * ((abs(y_pred - y_test)) / y_test))) print('Explained variance score (EVS):', metrics.explained_variance_score(y_test, y_pred)) print("") # Importance de chacun des prédicteurs dans la prédiction print("Prédicteurs utilisés:", list(predicteurs.columns)) print("Importance de chaque prédicteur:", regressor.feature_importances_) print("") # Graphique de l'importance des prédicteurs fig, ax = plt.subplots() y_pos = np.arange(len(list(predicteurs.columns))) ax.barh(y_pos, regressor.feature_importances_, align='center') ax.set_yticks(y_pos) ax.set_yticklabels(list(predicteurs.columns)) plt.show() # Affichage des résidus par rapport à l'échantillon de test (vérité) test_residuals = y_test - y_pred sns.scatterplot(x=y_test, y=test_residuals) plt.axhline(y=0, color='r', ls='--') plt.show() # ------------- Prédiction ------------------ # préparer les données pour la prédiction (downscaling) à 100m self.secteur.prepareData(train_model=False, targetResolution=targetResolution) # Prédiction dataframe_predict = self.secteur.getDf(predictors, train=False) #dataframe_predict = dataframe_predict.fillna(0) # à inclure si on veut masquer les nuages à 100m aussi y_downscale = regressor.predict(dataframe_predict.drop('LST', axis=1)) # *********** (à faire avec Landsat LST) **************** # Métriques de qualité sur le résultat prédit par rapport à l'échantillon de vérité terrain # print('Mean Absolute Error (MAE):', metrics.mean_absolute_error(y_test, y_pred)) # print('Mean Squared Error:', metrics.mean_squared_error(y_test, y_pred)) # print('Root Mean Squared Error:', np.sqrt(metrics.mean_squared_error(y_test, y_pred))) # Importance de chacun des prédicteurs (NDVI, NDWI, NDBI) dans la prédiction #print("Importance de chaque prédicteur", regressor.feature_importances_) # Affichage des résidus par rapport à l'échantillon de vérité terrain # ************* (à faire avec Landsat LST) ************** # test_residuals = y_test - y_pred # sns.scatterplot(x=y_test, y=test_residuals) # plt.axhline(y=0, color='r', ls='--') # plt.show() # sauvegarder le résultat avec une autre image (de mêmes dimensions et avec la même référence spatiale) # comme référence reference_image = Image(self.secteur.modis_image.lst ) # LST MODIS subdivisée (à 100m ou 30m) y_downscale_masked = ma.masked_array(y_downscale, self.secteur.mask.ravel()) y_downscale_masked = ma.filled( y_downscale_masked, np.nan) # on retire les valeurs masquées du output y_downscale_masked = y_downscale_masked.reshape( reference_image.ysize, reference_image.xsize) reference_image.save_band(y_downscale_masked, outputFile) # ------------- Correction pour les résidus ------------------ if residualCorrection: predicted_image = Image(outputFile) # ramener à 1km predicted_image.reprojectMatch( self.secteur.modis_image.lst.replace("_reproject", ""), reduce_zone=True) resampled_predicted_image = Image( outputFile.replace(".tif", "_reproject.tif")) # Conversion du array MODIS LST en un format compatible au Random Forest Regression tmp_lst_image_1km = Image(self.secteur.modis_image.lst) tmp_lst_image_1km.reprojectMatch( self.secteur.modis_image.lst.replace("_reproject", ""), reduce_zone=True) lst_image_1km = Image( self.secteur.modis_image.lst.replace("_reproject", "_reproject_reproject")) modis_array = lst_image_1km.getArray(masked=True, lower_valid_range=7500, upper_valid_range=65535) # convertir à des températures de surface en Celsius lst_metadata = lst_image_1km.getMetadata() # vérifier si le scale_factor est présent dans les métadonnées (c'est le cas pour AppEEARS, pas EarthData) if 'scale_factor' in lst_metadata: scale_factor = float( lst_metadata['scale_factor']) # multiplier par 0.02 add_offset = float(lst_metadata['add_offset']) else: scale_factor = float(0.02) add_offset = float(0) # conversion en Kelvin, puis en Celsius kelvin_array = np.add(np.multiply(modis_array, scale_factor), add_offset) lst_celsius_array = np.subtract(kelvin_array, 273.15) lst_image_1km.save_band(lst_celsius_array, r'data/MODIS_1km_Celsius.tif') # Calcul des résidus à 1km residus_1km = ma.subtract(lst_celsius_array, resampled_predicted_image.getArray()) # Sauvegarder l'image 1km pour pouvoir la ramener à 100m par la suite residus_1km_masked = ma.filled( residus_1km, np.nan) # on retire les valeurs masquées du output lst_image_1km.save_band(residus_1km_masked, r'data/residus_1km.tif') residus_1km_load = Image(r'data/residus_1km.tif') # Résidus de 1km -> 100m if targetResolution == 100: residus_1km_load.reproject(r'data/residus_1km.tif', r'data/residus_100m.tif', 'EPSG:32618', 'np.nan', '100.0', 'cubic') # Application des résidus sur le résultat residus_100m = Image(r'data/residus_100m.tif') predicted_image_with_residuals = ma.add( predicted_image.getArray(), residus_100m.getArray()) # Sauvegarder le résultat residus_100m.save_band(predicted_image_with_residuals, outputFile_withResidualCorrection) elif targetResolution == 30: residus_1km_load.reproject(r'data/residus_1km.tif', r'data/residus_30m.tif', 'EPSG:32618', 'np.nan', '30.0', 'cubic') # Application des résidus sur le résultat residus_30m = Image(r'data/residus_30m.tif') predicted_image_with_residuals = ma.add( predicted_image.getArray(), residus_30m.getArray()) # Sauvegarder le résultat residus_30m.save_band(predicted_image_with_residuals, outputFile_withResidualCorrection)