Update model weights and Docker image

app.py

@@ -3,13 +3,13 @@ import torch.nn as nn
 import torch.optim as optim
 import numpy as np
 from fastapi import FastAPI, UploadFile, File
-from sklearn.model_selection import KFold
 from sklearn.metrics import mean_squared_error
-from sklearn.preprocessing import OneHotEncoder
+import pandas as pd
+from sklearn.model_selection import train_test_split
 import csv
 import io
 
-from joblib import load, dump
+# from joblib import load, dump
 
 
 # Define the DNN model
@@ -32,95 +32,105 @@ class DNN(nn.Module):
 
 
 # Load the model
-model = DNN(input_size=7, hidden_size=128, output_size=1)
+model = DNN(input_size=6, hidden_size=256, output_size=1)
 
-# Initialize the OneHotEncoder
-encoder = OneHotEncoder(handle_unknown="ignore")
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+model = model.to(device)
+model.load_state_dict(torch.load("model_weights.pth", map_location=device))
 
 # Create a new FastAPI app instance
 app = FastAPI(docs_url="/", redoc_url="/new_redoc")
 
 
 # Create a POST endpoint
-@app.get("/generate/{squareFeet}/{bedrooms}/{bathrooms}/{neighborhood}/{yearBuilt}")
+@app.get(
+    "/generate/{Soil_Quality}/{Seed_Variety}/{Fertilizer_Amount_kg_per_hectare}/{Sunny_Days}/{Rainfall_mm}/{Irrigation_Schedule}"
+)
 def generate(
-    squareFeet: float,
-    bedrooms: float,
-    bathrooms: float,
-    neighborhood: str,
-    yearBuilt: float,
+    Soil_Quality: float,
+    Seed_Variety: float,
+    Fertilizer_Amount_kg_per_hectare: float,
+    Sunny_Days: float,
+    Rainfall_mm: float,
+    Irrigation_Schedule: float,
 ):
-    global model, encoder
-
-    # Apply the encoder to the neighborhood input
-    neighborhood_encoded = encoder.transform([[neighborhood]]).toarray()[0]
+    global model
 
     # Combine all inputs
-    input_data = [squareFeet, bedrooms, bathrooms, *neighborhood_encoded, yearBuilt]
+    input_data = [
+        Soil_Quality,
+        Seed_Variety,
+        Fertilizer_Amount_kg_per_hectare,
+        Sunny_Days,
+        Rainfall_mm,
+        Irrigation_Schedule,
+    ]
 
     input_data = torch.tensor([input_data], dtype=torch.float32)
+    input_data = input_data.to(device)
     prediction = model(input_data)
-    return {"output": prediction.item()}
+    return {"prediction": prediction.item()}
 
 
 @app.post("/train")
-async def train(file: UploadFile = File(...)):
-    global model, encoder
-
-    contents = await file.read()
-    data = list(csv.reader(io.StringIO(contents.decode("utf-8"))))
+async def train(
+    trainDatafile: UploadFile = File(...),
+    testDatafile: UploadFile = File(...),
+    epochs: int = 100,
+):
+    global model
 
-    data_np = np.array(data[1:], dtype=object)
+    contents1 = await trainDatafile.read()
+    train_data = pd.read_csv(io.StringIO(contents1.decode("utf-8")))
 
-    # Delete the fourth column
-    encoded_columns = encoder.fit_transform(data_np[:, 3].reshape(-1, 1))
-    data_np = np.delete(data_np, 3, axis=1)
-    data_np = np.concatenate((data_np, encoded_columns.toarray()), axis=1)
-    data_np = np.array(data_np, dtype=float)
+    contents2 = await testDatafile.read()
+    test_data = pd.read_csv(io.StringIO(contents2.decode("utf-8")))
 
-    # All columns except the last
-    X = data_np[:, :-1]
+    # Load the training and testing data
+    # test_data = pd.read_csv("dataset/agricultural_yield_test.csv")
 
-    # Only the last column
-    y = data_np[:, -1]
-    y = np.ravel(y)
+    # Convert data to numpy arrays
+    X_train = train_data.drop("Yield_kg_per_hectare", axis=1).values
+    y_train = train_data["Yield_kg_per_hectare"].values
+    X_test = test_data.drop("Yield_kg_per_hectare", axis=1).values
+    y_test = test_data["Yield_kg_per_hectare"].values
 
     # Convert data to torch tensors
-    X = torch.tensor(X, dtype=torch.float32)
-    y = torch.tensor(y, dtype=torch.float32)
+    X_train = torch.tensor(X_train, dtype=torch.float32)
+    X_train = X_train.to(device)
+    y_train = torch.tensor(y_train, dtype=torch.float32)
+    y_train = y_train.to(device)
+
+    X_test = torch.tensor(X_test, dtype=torch.float32)
+    X_test = X_test.to(device)
+    y_test = torch.tensor(y_test, dtype=torch.float32)
 
     # Define loss function and optimizer
     criterion = nn.MSELoss()
-    optimizer = optim.Adam(model.parameters(), lr=0.0001)
+    optimizer = optim.Adam(model.parameters(), lr=0.001)
 
-    # Fit the model
-    kf = KFold(n_splits=4)
-    accuracies = []
-
-    epochs = 25  # Define the number of epochs
+    rmseList = []
 
     for epoch in range(epochs):
-        for train_index, test_index in kf.split(X):
-            X_train, X_test = X[train_index], X[test_index]
-            y_train, y_test = y[train_index], y[test_index]
-
-            optimizer.zero_grad()
-
-            # Forward pass
-            outputs = model(X_train)
-            loss = criterion(outputs, y_train.unsqueeze(1))
+        optimizer.zero_grad()
 
-            # Backward pass and optimization
-            loss.backward()
-            optimizer.step()
+        # Forward pass
+        outputs = model(X_train)
+        loss = criterion(outputs, y_train.unsqueeze(1))
 
-            predictions = model(X_test)
-            rmse = np.sqrt(mean_squared_error(y_test, predictions.detach().numpy()))
-            accuracies.append(rmse)
+        # Backward pass and optimization
+        loss.backward()
+        optimizer.step()
 
-        average_rmse = sum(accuracies) / len(accuracies)
-        print(f"Epoch: {epoch+1}, Average RMSE: {average_rmse}")
+        predictions = model(X_test)
+        rmse = np.sqrt(
+            mean_squared_error(
+                y_test.cpu().detach().numpy(), predictions.cpu().detach().numpy()
+            )
+        )
+        print(f"Epoch: {epoch+1}, RMSE: {float(rmse)}")
+        rmseList.append(float(rmse))
 
-    dump(model, "model.joblib")
+    torch.save(model.state_dict(), "model_weights.pth")
 
-    return {"filename": file.filename, "average_rmse": average_rmse}
+    return {"rmse": rmseList}

docker-compose.yml

@@ -1,14 +1,14 @@
 version: '3.8'
 services:
   your-service:
-    image: prueba-ia
+    image: mi-imagen
+    shm_size: '2gb'
     ports:
       - "7860:7860"
     deploy:
       resources:
         limits:
-          memory: 512M
-          shm_size: 2G
+          memory: 2G
         reservations:
           devices:
             - driver: nvidia

requirements.txt

@@ -29,3 +29,4 @@ uvloop==0.19.0
 watchgod==0.8.2
 websockets==12.0
 torch
+pandas

test.py

@@ -0,0 +1,5 @@
+import pandas as pd
+
+test_data = pd.read_csv("dataset/agricultural_yield_test.csv")
+
+print(test_data.head())