Upload folder using huggingface_hub

MLBaseModel.py

@@ -0,0 +1,17 @@
+import torch
+import torch.nn as nn
+
+class MLBaseModel(nn.Module):
+    def __init__(self, input_dim):
+        super(MLBaseModel, self).__init__()
+        self.fc1 = nn.Linear(input_dim, 256)
+        self.fc2 = nn.Linear(256, 128)
+        self.fc3 = nn.Linear(128, 64)
+        self.fc4 = nn.Linear(64, 2)  # Output 2 values: sale_price and days_on_market
+
+    def forward(self, x):
+        x = torch.relu(self.fc1(x))
+        x = torch.relu(self.fc2(x))
+        x = torch.relu(self.fc3(x))
+        x = self.fc4(x)
+        return x

MLBaseModelDriver.py

@@ -0,0 +1,159 @@
+import torch
+import sys
+import pandas as pd
+from typing import TypedDict, Optional, Tuple
+import datetime
+import math
+import importlib.util
+from huggingface_hub import hf_hub_download
+import pickle
+
+
+"""
+Data container class representing the data shape of the synapse coming into `run_inference`
+"""
+
+
+class ProcessedSynapse(TypedDict):
+    id: Optional[str]
+    nextplace_id: Optional[str]
+    property_id: Optional[str]
+    listing_id: Optional[str]
+    address: Optional[str]
+    city: Optional[str]
+    state: Optional[str]
+    zip_code: Optional[str]
+    price: Optional[float]
+    beds: Optional[int]
+    baths: Optional[float]
+    sqft: Optional[int]
+    lot_size: Optional[int]
+    year_built: Optional[int]
+    days_on_market: Optional[int]
+    latitude: Optional[float]
+    longitude: Optional[float]
+    property_type: Optional[str]
+    last_sale_date: Optional[str]
+    hoa_dues: Optional[float]
+    query_date: Optional[str]
+
+
+"""
+This class must do two things
+1) The constructor must load the model
+2) This class must implement a method called `run_inference` that takes the input data and returns a tuple
+    of float, str representing the predicted sale price and the predicted sale date.
+"""
+
+
+class MLBaseModelDriver:
+
+    def __init__(self):
+        self.model, self.label_encoder, self.scaler = self.load_model()
+
+    def load_model(self) -> Tuple[any, any, any]:
+        """
+        load the model and model parameters
+        :return: model, label encoder, and scaler
+        """
+        print(f"Loading model...")
+        model_file, scaler_file, label_encoders_file, model_class_file = self._download_model_files()
+        model_class = self._import_model_class(model_class_file)
+
+        model = model_class(input_dim=4)
+        state_dict = torch.load(model_file, weights_only=False)
+        model.load_state_dict(state_dict)
+        model.eval()
+
+        # Load additional artifacts
+        with open(scaler_file, 'rb') as f:
+            scaler = pickle.load(f)
+
+        with open(label_encoders_file, 'rb') as f:
+            label_encoders = pickle.load(f)
+
+        print(f"Model Loaded.")
+        return model, label_encoders, scaler
+
+    def _download_model_files(self) -> Tuple[str, str, str, str]:
+        """
+        download files from hugging face
+        :return: downloaded files
+        """
+        model_path = "Nickel5HF/NextPlace"
+
+        # Download the model files from the Hugging Face Hub
+        model_file = hf_hub_download(repo_id=model_path, filename="model_files/real_estate_model.pth")
+        scaler_file = hf_hub_download(repo_id=model_path, filename="model_files/scaler.pkl")
+        label_encoders_file = hf_hub_download(repo_id=model_path, filename="model_files/label_encoder.pkl")
+        model_class_file = hf_hub_download(repo_id=model_path, filename="MLBaseModel.py")
+
+        # Load the model and artifacts
+        return model_file, scaler_file, label_encoders_file, model_class_file
+
+    def _import_model_class(self, model_class_file):
+        """
+        import the model class and instantiate it
+        :param model_class_file: file path to the model class
+        :return: None
+        """
+        # Reference docs here: https://docs.python.org/3/library/importlib.html#importlib.util.spec_from_loader
+        module_name = "MLBaseModel"
+        spec = importlib.util.spec_from_file_location(module_name, model_class_file)
+        model_module = importlib.util.module_from_spec(spec)
+        sys.modules[module_name] = model_module
+        spec.loader.exec_module(model_module)
+
+        if hasattr(model_module, "MLBaseModel"):
+            return model_module.MLBaseModel
+        else:
+            raise AttributeError(f"The module does not contain a class named 'MLBaseModel'")
+
+    def run_inference(self, input_data: ProcessedSynapse) -> Tuple[float, str]:
+        """
+        run inference using the MLBaseModel
+        :param input_data: synapse from the validator
+        :return: the predicted sale price and date
+        """
+        input_tensor = self._preprocess_input(input_data)
+
+        with torch.no_grad():
+            prediction = self.model(input_tensor)
+            predicted_sale_price, predicted_days_on_market = prediction[0].numpy()
+            predicted_days_on_market = math.floor(predicted_days_on_market)
+            predicted_sale_date = self._sale_date_predictor(input_data['days_on_market'], predicted_days_on_market)
+
+        return float(predicted_sale_price), predicted_sale_date.strftime("%Y-%m-%d")
+
+    def _sale_date_predictor(self, days_on_market: int, predicted_days_on_market: int) -> datetime.date:
+        """
+        convert predicted days on market to a sale date
+        :param days_on_market: number of days this home has been on the market
+        :param predicted_days_on_market: the predicted number of days for this home on the market
+        :return: the predicted sale date
+        """
+        if days_on_market < predicted_days_on_market:
+            days_until_sale = predicted_days_on_market - days_on_market
+            sale_date = datetime.date.today() + datetime.timedelta(days=days_until_sale)
+            return sale_date
+        else:
+            return datetime.date.today() + datetime.timedelta(days=1)
+
+    def _preprocess_input(self, data: ProcessedSynapse) -> torch.tensor:
+        """
+        preprocess the input for inference
+        :param data: synapse from the validator
+        :return: tensor representing the synapse
+        """
+        df = pd.DataFrame([data])
+        default_beds = 3
+        default_sqft = 1500.0
+        default_property_type = '6'
+        df['beds'] = df['beds'].fillna(default_beds)
+        df['sqft'] = pd.to_numeric(df['sqft'], errors='coerce').fillna(default_sqft)
+        df['property_type'] = df['property_type'].fillna(default_property_type)
+        df['property_type'] = df['property_type'].astype(int)
+        df[['sqft', 'price']] = self.scaler.transform(df[['sqft', 'price']])
+        X = df[['beds', 'sqft', 'property_type', 'price']]
+        input_tensor = torch.tensor(X.values, dtype=torch.float32)
+        return input_tensor

README.md

@@ -0,0 +1,2 @@
+# NextPlace
+- Models for the NextPlace subnet

StatisticalBaseModel.py

@@ -0,0 +1,131 @@
+from typing import Tuple, TypedDict, Optional
+import datetime
+
+
+class ProcessedSynapse(TypedDict):
+    id: Optional[str]
+    nextplace_id: Optional[str]
+    property_id: Optional[str]
+    listing_id: Optional[str]
+    address: Optional[str]
+    city: Optional[str]
+    state: Optional[str]
+    zip_code: Optional[str]
+    price: Optional[float]
+    beds: Optional[int]
+    baths: Optional[float]
+    sqft: Optional[int]
+    lot_size: Optional[int]
+    year_built: Optional[int]
+    days_on_market: Optional[int]
+    latitude: Optional[float]
+    longitude: Optional[float]
+    property_type: Optional[str]
+    last_sale_date: Optional[str]
+    hoa_dues: Optional[float]
+    query_date: Optional[str]
+    market: Optional[str]
+
+
+class StatisticalBaseModel:
+
+    def __init__(self):
+        self._load_model()
+
+    def _load_model(self):
+        """
+        Perform any actions needed to load the model.
+        EX: Establish API connections, download an ML model for inference, etc...
+        """
+        print("Loading model...")
+        # Optional model loading
+        print("Model loaded.")
+
+    def _get_average_for_market(self, market: str) -> int:
+        """
+        Get the average days on market for a house in a given market
+        :param market: the housing market
+        :return: the average days on market
+        """
+        # You probably want to update this based on the current season. Houses sell faster in the summer.
+        # Add more logic for other housing markets!
+        if market == 'San Francisco':
+            return 23
+        elif market == 'Los Angeles':
+            return 68
+        elif market == 'Seattle':
+            return 27
+        elif market == 'Austin':
+            return 78
+        elif market == 'Houston':
+            return 73
+        elif market == 'Chicago':
+            return 25
+        elif market == 'New York':
+            return 20
+        elif market == 'Denver':
+            return 24
+        return 34
+
+
+    def _sale_date_predictor(self, input_data: ProcessedSynapse):
+        """
+        Calculate the expected sale date based on the national average
+        :param days_on_market: number of days this house has been on the market
+        :return: the predicted sale date, based on the national average of 34 days
+        """
+        if 'days_on_market' not in input_data:
+            return datetime.date.today() + datetime.timedelta(days=1)
+
+        if 'market' not in input_data:
+            average = 34
+
+        else:
+            average = self._get_average_for_market(input_data['market'])
+
+        days_on_market = input_data['days_on_market']
+        if days_on_market < average:
+            days_until_sale = average - days_on_market
+            sale_date = datetime.date.today() + datetime.timedelta(days=days_until_sale)
+            return sale_date
+        else:
+            return datetime.date.today() + datetime.timedelta(days=1)
+
+    def _get_price_multiplier(self, market: str) -> float:
+        """
+        Calculate the price multiplier based on the market
+        :param market: the marked the house is in
+        :return: the multiplier for the predicted price
+        """
+        # You may want to add more logic to check zipcode for more precise price multipliers
+        # Add more logic for other housing markets!
+        if market == 'San Francisco':
+            return 1.18  # 18% above listing
+        elif market == 'Los Angeles':
+            return 1.2  # 22% above listing
+        elif market == 'Seattle':
+            return 1.13  # 13% above listing
+        elif market == 'Austin':
+            return 1.11  # 11% above listing
+        elif market == 'Houston':
+            return 1.15  # 15% above listing
+        elif market == 'Chicago':
+            return 1.12  # 12% above listing
+        elif market == 'New York':
+            return 1.05  # 5% above listing
+        elif market == 'Denver':
+            return 1.11  # 11% above listing
+        return 1.0
+
+    def run_inference(self, input_data: ProcessedSynapse) -> Tuple[float, str]:
+        """
+        Predict the sale price and sale date for the house represented by `input_data`
+        :param input_data: a formatted Synapse from the validator, representing a currently listed house
+        :return: the predicted sale price and predicted sale date for this home
+        """
+        listing_price = float(input_data['price']) if 'price' in input_data else 1.0
+        sale_multiplier = self._get_price_multiplier(input_data['market']) if 'market' in input_data else 1.0
+        predicted_sale_price = listing_price * sale_multiplier
+        predicted_sale_date = self._sale_date_predictor(input_data)
+        predicted_sale_date = predicted_sale_date.strftime("%Y-%m-%d")
+        return predicted_sale_price, predicted_sale_date

model_files/label_encoder.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2fd02a7b03d8323c065fbb3a010f92710b96d568fe18f48922de1b106d0928e9
+size 306

model_files/real_estate_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9ead0cc482ac184bf4aff9500dcfd288304a243200621b09574713fb20fa6dbe
+size 2079339

model_files/scaler.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7c321473fc77b93773052027f5dc5e2ae03c51b3b9a39c093c674444103caabc
+size 600

real_estate_model.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:39811330ff68ab47c4838bceacc0fb8e87c0120282506d03f1119992996062a0
+size 173496