geocif 0.1.32__tar.gz → 0.1.33__tar.gz

{geocif-0.1.32/geocif.egg-info → geocif-0.1.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: geocif
-Version: 0.1.32
+Version: 0.1.33
 Summary: Models to visualize and forecast crop conditions and yields
 Home-page: https://ritviksahajpal.github.io/yield_forecasting/
 Author: Ritvik Sahajpal

{geocif-0.1.32 → geocif-0.1.33}/geocif/geocif.py

@@ -222,6 +222,10 @@ class Geocif:
             self.logger.info(f"Selected features: {self.selected_features}")
 
             """ Update model to include conformal estimates """
+            if "lat" not in self.selected_features:
+                self.selected_features.append("lat")
+            if "lon" not in self.selected_features:
+                self.selected_features.append("lon")
             X_train = df_region[self.selected_features + self.cat_features]
             dir_output = (
                 self.dir_analysis
@@ -275,6 +279,12 @@ class Geocif:
                         verbose=False,
                         # callbacks=[TQDMCallback(self.best_hyperparams["iterations"])],
                     )
+                elif self.model_name == "geospaNN":
+                    self.model.fit(
+                        X_train,
+                        y_train,
+                        # callbacks=[TQDMCallback(self.best_hyperparams["iterations"])],
+                    )
                 elif self.model_name == "merf":
                     Z_train = np.ones((len(X_train), 1))
                     clusters_train = df_region["Region"]
@@ -341,6 +351,25 @@ class Geocif:
                     X_test, Z_test, clusters_test.astype("object")
                 )
                 best_hyperparameters = self.model.fe_model.get_params().copy()
+            elif self.model_name == "geospaNN":
+                import torch
+                import geospaNN
+
+                # Remove any categorical features
+                X_test = X_test.drop(columns=self.cat_features)
+                X = torch.from_numpy(X_test.to_numpy()).float()
+                coord = torch.from_numpy(self.df_test[['lon', 'lat']].to_numpy()).float()
+
+                p = X.shape[1]
+                n = X.shape[0]
+                nn = 5
+
+                data = geospaNN.make_graph(X, Y, coord, nn)
+
+                # remove categorical features from df_train
+                data_train = df_region[self.selected_features + self.cat_features + [self.target]]
+                w_train = data_train.y - self.estimate(data_train.x)
+
             else:
                 y_pred = self.model.predict(X_test)
                 best_hyperparameters = self.model.get_params().copy()
@@ -527,6 +556,10 @@ class Geocif:
         if self.use_outlook_as_feature:
             self.feature_names.append("FCST")
 
+        # Add lat and lon to feature names
+        self.feature_names.append("lat")
+        self.feature_names.append("lon")
+
         self.selected_features = []
 
     def loop_ml(self, stages, dict_selected_features, dict_best_cei):
@@ -782,6 +815,13 @@ class Geocif:
             how="outer",
         )
 
+        # Add a lat and lon column to self.dg_country
+        self.dg_country["lat"] = self.dg_country.centroid.y
+        self.dg_country["lon"] = self.dg_country.centroid.x
+
+        # Add lat and lon columns to df by merging on Country Region column
+        df = df.merge(self.dg_country[["Country Region", "lat", "lon"]].drop_duplicates(), on="Country Region", how="left")
+
         dict_kwargs = {}
         dict_kwargs["all_stages"] = self.all_stages
         dict_kwargs["target_col"] = self.target

{geocif-0.1.32 → geocif-0.1.33}/geocif/ml/spatial_autocorrelation.py

@@ -77,7 +77,7 @@ def create_base_weights(merged_df):
     return w_base, dg
 
 
-def create_weights_for_year(dg_country, regions_with_data):
+def create_weights_for_year(dg_country, regions_with_data, year):
     """
 
     Args:
@@ -97,10 +97,8 @@ def create_weights_for_year(dg_country, regions_with_data):
     ]
     if no_neighbors:
         dg = dg.drop(index=no_neighbors[0]).reset_index(drop=True)
-        try:
-            wt = weights.Queen.from_dataframe(dg[["Country Region", "geometry"]])
-        except:
-            breakpoint()
+        wt = weights.Queen.from_dataframe(dg[["Country Region", "geometry"]])
+
     return wt, dg
 
 
@@ -125,6 +123,8 @@ def compute_morans_i(merged_df):
     for year in tqdm(years, desc="Compute Moran's I"):
         year_data = merged_df[merged_df["Harvest Year"] == year]
         regions_with_data = year_data["Country Region"].unique()
+        if len(regions_with_data) < 3:
+            continue
         year_data = year_data[year_data["Country Region"].isin(regions_with_data)]
 
         y = year_data[
@@ -132,9 +132,8 @@ def compute_morans_i(merged_df):
         ].drop_duplicates()
         dg_country = year_data[["Country Region", "geometry"]].drop_duplicates()
 
-        w, x = create_weights_for_year(dg_country, regions_with_data)
+        w, x = create_weights_for_year(dg_country, regions_with_data, year)
         y = y[y["Country Region"].isin(x["Country Region"])]
-
         if len(y) > 1:
             try:
                 mi = esda.Moran(y["Yield (tn per ha)"].values, w, permutations=999)

{geocif-0.1.32 → geocif-0.1.33}/geocif/ml/trainers.py

@@ -289,6 +289,40 @@ def auto_train(
             model = LinearGAM(n_splines=25, spline_order=3).gridsearch(
                 X_train.values, y_train.values, lam=np.logspace(-3, 3, 11)
             )
+        elif model_name == "geospaNN":
+            import torch
+            import geospaNN
+
+            # Remove any categorical features
+            X_train = X_train.drop(columns=cat_features)
+            X = torch.from_numpy(X_train.to_numpy()).float()
+            Y = torch.from_numpy(y_train.to_numpy().reshape(-1)).float()
+
+            coord = torch.from_numpy(df_train[['lon', 'lat']].to_numpy()).float()
+
+            p = X.shape[1]
+            n = X.shape[0]
+            nn = 5
+
+            data = geospaNN.make_graph(X, Y, coord, nn)
+
+            mlp = torch.nn.Sequential(
+                torch.nn.Linear(p, 50),
+                torch.nn.ReLU(),
+                torch.nn.Linear(50, 20),
+                torch.nn.ReLU(),
+                torch.nn.Linear(20, 10),
+                torch.nn.ReLU(),
+                torch.nn.Linear(10, 1),
+            )
+
+            # Split data
+            data_train, data_val, data_test = geospaNN.split_data(X, Y, coord, neighbor_size=nn, test_proportion=0.1)
+            theta0 = geospaNN.theta_update(torch.tensor([1, 1.5, 0.01]), mlp(data_train.x).squeeze() - data_train.y, data_train.pos, neighbor_size=5)
+            model = geospaNN.nngls(p=p, neighbor_size=nn, coord_dimensions=2, mlp=mlp, theta=torch.tensor(theta0))
+            nngls_model = geospaNN.nngls_train(model, lr=0.01, min_delta=0.001)
+            # Log training process
+            training_log = nngls_model.train(data_train, data_val, data_test, Update_init=10, Update_step=10)
         elif model_name == "xgboost":
             raise NotImplementedError
         else:

{geocif-0.1.32 → geocif-0.1.33/geocif.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: geocif
-Version: 0.1.32
+Version: 0.1.33
 Summary: Models to visualize and forecast crop conditions and yields
 Home-page: https://ritviksahajpal.github.io/yield_forecasting/
 Author: Ritvik Sahajpal

{geocif-0.1.32 → geocif-0.1.33}/setup.py

@@ -50,6 +50,6 @@ setup(
     test_suite="tests",
     tests_require=test_requirements,
     url="https://ritviksahajpal.github.io/yield_forecasting/",
-    version="0.1.32",
+    version="0.1.33",
     zip_safe=False,
 )