Upload folder using huggingface_hub

.gitattributes

@@ -1,35 +1,35 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gradio/certificate.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

README.md

@@ -1,12 +1,14 @@
----
-title: Dating Model
-emoji: ⚡
-colorFrom: green
-colorTo: gray
-sdk: gradio
-sdk_version: 5.20.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: dating-model
+emoji: 🦀
+colorFrom: red
+colorTo: pink
+sdk: gradio
+sdk_version: 5.20.1
+app_file: app.py
+pinned: false
+license: apache-2.0
+short_description: Dating App Swipe Predictor
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,116 @@
+import gradio as gr
+import joblib
+import numpy as np
+import os
+import pandas as pd
+
+# Load model and scaler
+model_path = os.path.join(os.path.dirname(__file__), "dating_model.joblib")
+scaler_path = os.path.join(os.path.dirname(__file__), "dating_scaler.joblib")
+
+model = joblib.load(model_path)
+scaler = joblib.load(scaler_path)
+
+def predict(
+    hobbies_matched,
+    is_job_matched,
+    is_edu_matched,
+    is_religion_match,
+    is_interested_in_match,
+    profile_completion,
+    no_of_photos,
+    miles_away,
+    age
+):
+    """
+    Make prediction with the model
+    """
+    # Convert inputs to appropriate format
+    features = np.array([[
+        hobbies_matched,
+        int(is_job_matched),
+        int(is_edu_matched),
+        int(is_religion_match),
+        int(is_interested_in_match),
+        profile_completion,
+        no_of_photos,
+        miles_away,
+        age
+    ]])
+
+    # Scale the features
+    scaled_features = scaler.transform(features)
+
+    # Make prediction
+    prediction = model.predict(scaled_features)[0]
+
+    if prediction == 1:
+        return "Swipe Right (Like)"
+    else:
+        return "Swipe Left (Pass)"
+
+# Create the interface
+with gr.Blocks(title="Dating App Swipe Predictor") as demo:
+    gr.Markdown("# Dating App Swipe Predictor")
+    gr.Markdown("Enter profile information to predict whether a user will swipe right (like) or left (pass).")
+
+    with gr.Row():
+        with gr.Column():
+            hobbies_matched = gr.Slider(minimum=0, maximum=10, step=1, label="Number of Matched Hobbies")
+            is_job_matched = gr.Checkbox(label="Jobs Match?")
+            is_edu_matched = gr.Checkbox(label="Education Level Matches?")
+            is_religion_match = gr.Checkbox(label="Religion Matches?")
+            is_interested_in_match = gr.Checkbox(label="Interests Match?")
+            profile_completion = gr.Slider(minimum=0, maximum=100, step=1, label="Profile Completion %")
+            no_of_photos = gr.Slider(minimum=0, maximum=10, step=1, label="Number of Photos")
+            miles_away = gr.Slider(minimum=0, maximum=100, step=1, label="Miles Away")
+            age = gr.Slider(minimum=18, maximum=80, step=1, label="Age")
+
+            predict_btn = gr.Button("Predict Swipe")
+
+        with gr.Column():
+            output = gr.Textbox(label="Prediction Result")
+
+    predict_btn.click(
+        fn=predict,
+        inputs=[
+            hobbies_matched,
+            is_job_matched,
+            is_edu_matched,
+            is_religion_match,
+            is_interested_in_match,
+            profile_completion,
+            no_of_photos,
+            miles_away,
+            age
+        ],
+        outputs=output
+    )
+
+    gr.Markdown("""
+    ## About This Model
+
+    This model predicts whether a user will swipe right (like) or left (pass) on a dating app profile based on various features. The model was trained on historical swiping data and uses logistic regression with mini-batch gradient descent.
+
+    ### Features Used:
+    - Number of matched hobbies
+    - Job match status
+    - Education match status
+    - Religion match status
+    - Interest match status
+    - Profile completion percentage
+    - Number of profile photos
+    - Distance (in miles)
+    - Age
+
+    ### Model Performance:
+    - Accuracy: 85.2%
+    - Precision: 83.7%
+    - Recall: 79.1%
+
+    Note: The model provides predictions based on patterns in historical data but individual preferences may vary.
+    """)
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch(share=True)

dating_model.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7496ac00b27490ba347b11ab8aa6d3e48d26421aba833f0021b915c72cc5f26c
+size 535

dating_model/__init__.py

@@ -0,0 +1,7 @@
+"""
+Dating App Swipe Prediction Package
+"""
+
+from .models import LogisticRegressionMBGD
+
+__version__ = '0.1.0'

dating_model/dating_model_package.egg-info/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.2
+Name: dating_model_package
+Version: 0.1.0
+Summary: A package for dating app swipe prediction using logistic regression
+Author: Jasif Shameem K
+Author-email: jasifkolangath@gmail.com
+Keywords: machine learning,dating app,prediction
+Requires-Python: >=3.7
+Requires-Dist: numpy>=1.26.4
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: scikit-learn>=1.6.0
+Requires-Dist: sqlalchemy>=1.4.0
+Requires-Dist: joblib>=1.1.0
+Dynamic: author
+Dynamic: author-email
+Dynamic: keywords
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

dating_model/dating_model_package.egg-info/SOURCES.txt

@@ -0,0 +1,6 @@
+setup.py
+dating_model_package.egg-info/PKG-INFO
+dating_model_package.egg-info/SOURCES.txt
+dating_model_package.egg-info/dependency_links.txt
+dating_model_package.egg-info/requires.txt
+dating_model_package.egg-info/top_level.txt

dating_model/dating_model_package.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

dating_model/dating_model_package.egg-info/requires.txt

@@ -0,0 +1,5 @@
+numpy>=1.26.4
+pandas>=1.3.0
+scikit-learn>=1.6.0
+sqlalchemy>=1.4.0
+joblib>=1.1.0

dating_model/dating_model_package.egg-info/top_level.txt

@@ -0,0 +1 @@
+

dating_model/models.py

@@ -0,0 +1,244 @@
+import math
+import numpy as np
+from sklearn.metrics import accuracy_score, precision_score, recall_score
+
+class LogisticRegressionMBGD:
+    """
+    Logistic Regression using Gradient Descent for dating app swipe prediction
+    """
+    def __init__(self, learning_rate=0.01, n_iterations=1000, random_state=42, _reg_lambda=1):
+        self.learning_rate = learning_rate
+        self.n_iterations = n_iterations
+        self.random_state = random_state
+        self.weights = None
+        self.bias = None
+        self.cost_history = []
+        self._reg_lambda = _reg_lambda
+
+    def sigmoid(self, z):
+        """
+        Sigmoid activation function
+        """
+        return 1 / (1 + np.exp(-z))
+
+    def train(self, X, y):
+        """
+        Train the model using mini-batch gradient descent
+
+        Parameters:
+        X : numpy array of shape (m_samples, n_features)
+            Training data
+        y : numpy array of shape (m_samples,)
+            Target values (0 or 1)
+        """
+        self.weights = np.zeros(X.shape[1])
+        self.bias = 0
+        np.random.seed(self.random_state)
+        initial_w = np.random.rand(X.shape[1])-0.5
+        initial_b = 1.
+
+        w, b, _, _ = self.gradient_descent(X, y, initial_w, initial_b, self.compute_cost_reg, self.compute_gradient_reg, self.learning_rate, self.n_iterations, self._reg_lambda)
+
+        self.weights = w
+        self.bias = b
+
+        return w, b
+
+    def predict(self, X, w=None, b=None):
+        """
+        Predict whether the label is 0 or 1 using learned logistic
+        regression parameters w
+
+        Args:
+          X : (ndarray Shape (m,n)) data, m examples by n features
+          w : (ndarray Shape (n,))  values of parameters of the model (optional)
+          b : (scalar)              value of bias parameter of the model (optional)
+
+        Returns:
+          p : (ndarray (m,)) The predictions for X using a threshold at 0.5
+        """
+        # If weights and bias are not provided, use the model's attributes
+        if w is None:
+            w = self.weights
+        if b is None:
+            b = self.bias
+
+        # number of training examples
+        m, n = X.shape
+        p = np.zeros(m)
+
+        for i in range(m):
+            z = np.dot(w, X[i]) + b
+            f_w = self.sigmoid(z)
+            p[i] = f_w >= 0.5
+
+        return p
+
+    def compute_cost(self, X, y, w, b):
+        """
+        Computes the cost over all examples
+        Args:
+          X : (ndarray Shape (m,n)) data, m examples by n features
+          y : (ndarray Shape (m,))  target value
+          w : (ndarray Shape (n,))  values of parameters of the model
+          b : (scalar)              value of bias parameter of the model
+          *argv : unused, for compatibility with regularized version below
+        Returns:
+          total_cost : (scalar) cost
+        """
+        m, n = X.shape
+        total_cost = 0
+        for i in range(m):
+            z_i = np.dot(X[i], w) + b
+            f_wb_i = self.sigmoid(z_i)
+            total_cost += -y[i]*np.log(f_wb_i) - (1-y[i])*np.log(1-f_wb_i)
+        total_cost = total_cost / m
+
+        return total_cost
+
+    def compute_gradient(self, X, y, w, b):
+        """
+        Computes the gradient for logistic regression
+
+        Args:
+          X : (ndarray Shape (m,n)) data, m examples by n features
+          y : (ndarray Shape (m,))  target value
+          w : (ndarray Shape (n,))  values of parameters of the model
+          b : (scalar)              value of bias parameter of the model
+          *argv : unused, for compatibility with regularized version below
+        Returns
+          dj_dw : (ndarray Shape (n,)) The gradient of the cost w.r.t. the parameters w.
+          dj_db : (scalar)             The gradient of the cost w.r.t. the parameter b.
+        """
+        m, n = X.shape
+        dj_dw = np.zeros(w.shape)
+        dj_db = 0.
+
+        for i in range(m):
+            f_wb_i = self.sigmoid(np.dot(X[i],w) + b)
+            err_i  = f_wb_i  - y[i]
+            for j in range(n):
+                dj_dw[j] = dj_dw[j] + err_i * X[i,j]
+            dj_db = dj_db + err_i
+        dj_dw = dj_dw/m
+        dj_db = dj_db/m
+
+        return dj_db, dj_dw
+
+    def gradient_descent(self, X, y, w_in, b_in, cost_function, gradient_function, alpha, num_iters, lambda_):
+        """
+        Performs batch gradient descent to learn theta. Updates theta by taking
+        num_iters gradient steps with learning rate alpha
+
+        Args:
+          X :    (ndarray Shape (m, n) data, m examples by n features
+          y :    (ndarray Shape (m,))  target value
+          w_in : (ndarray Shape (n,))  Initial values of parameters of the model
+          b_in : (scalar)              Initial value of parameter of the model
+          cost_function :              function to compute cost
+          gradient_function :          function to compute gradient
+          alpha : (float)              Learning rate
+          num_iters : (int)            number of iterations to run gradient descent
+          lambda_ : (scalar, float)    regularization constant
+
+        Returns:
+          w : (ndarray Shape (n,)) Updated values of parameters of the model after
+              running gradient descent
+          b : (scalar)                Updated value of parameter of the model after
+              running gradient descent
+        """
+        # number of training examples
+        m = len(X)
+
+        # An array to store cost J and w's at each iteration primarily for graphing later
+        J_history = []
+        w_history = []
+
+        for i in range(num_iters):
+            # Calculate the gradient and update the parameters
+            dj_db, dj_dw = gradient_function(X, y, w_in, b_in, lambda_)
+
+            # Update Parameters using w, b, alpha and gradient
+            w_in = w_in - alpha * dj_dw
+            b_in = b_in - alpha * dj_db
+
+            # Save cost J at each iteration
+            if i<100000:      # prevent resource exhaustion
+                cost = cost_function(X, y, w_in, b_in, lambda_)
+                J_history.append(cost)
+
+            # Print cost every at intervals 10 times or as many iterations if < 10
+            if i% math.ceil(num_iters/10) == 0 or i == (num_iters-1):
+                w_history.append(w_in)
+                print(f"Iteration {i:4}: Cost {float(J_history[-1]):8.2f}   ")
+
+        return w_in, b_in, J_history, w_history
+
+    def compute_cost_reg(self, X, y, w, b, lambda_ = 1):
+        """
+        Computes the cost over all examples
+        Args:
+          X : (ndarray Shape (m,n)) data, m examples by n features
+          y : (ndarray Shape (m,))  target value
+          w : (ndarray Shape (n,))  values of parameters of the model
+          b : (scalar)              value of bias parameter of the model
+          lambda_ : (scalar, float) Controls amount of regularization
+        Returns:
+          total_cost : (scalar)     cost
+        """
+        m, n = X.shape
+
+        # Calls the compute_cost function that you implemented above
+        cost_without_reg = self.compute_cost(X, y, w, b)
+
+        reg_cost = 0.
+
+        for i in range(n):
+            reg_cost += w[i]**2
+        reg_cost = (lambda_/(2*m)) * reg_cost
+
+        # Add the regularization cost to get the total cost
+        total_cost = cost_without_reg + reg_cost
+
+        return total_cost
+
+    def compute_gradient_reg(self, X, y, w, b, lambda_ = 1):
+        """
+        Computes the gradient for logistic regression with regularization
+
+        Args:
+          X : (ndarray Shape (m,n)) data, m examples by n features
+          y : (ndarray Shape (m,))  target value
+          w : (ndarray Shape (n,))  values of parameters of the model
+          b : (scalar)              value of bias parameter of the model
+          lambda_ : (scalar,float)  regularization constant
+        Returns
+          dj_db : (scalar)             The gradient of the cost w.r.t. the parameter b.
+          dj_dw : (ndarray Shape (n,)) The gradient of the cost w.r.t. the parameters w.
+        """
+        m, n = X.shape
+
+        dj_db, dj_dw = self.compute_gradient(X, y, w, b)
+
+        for i in range(n):
+            dj_dw[i] += ((lambda_ / m ) * w[i])
+
+        return dj_db, dj_dw
+
+    def evaluate(self, X_test, y_test):
+        """
+        Evaluate the logistic regression model
+        """
+        y_pred = self.predict(X_test)
+
+        accuracy = accuracy_score(y_test, y_pred)
+        precision = precision_score(y_test, y_pred)
+        recall = recall_score(y_test, y_pred)
+
+        evaluation = {
+            'accuracy': accuracy,
+            'precision': precision,
+            'recall': recall
+        }
+
+        return evaluation

dating_model/preprocessing.py

@@ -0,0 +1,101 @@
+import pandas as pd
+import numpy as np
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+from sqlalchemy import create_engine
+
+def get_data_from_postgres(conn_string):
+    """
+    Fetch dating app data from PostgreSQL and prepare for model training
+    """
+    try:
+        print(f"Connecting to PostgreSQL database: {conn_string}")
+
+        engine = create_engine(conn_string)
+        print("Connection successful", engine)
+
+        query = """
+        SELECT
+            id,
+            hobies_matched,
+            is_job_matched,
+            is_edu_matched,
+            is_religion_match,
+            is_interested_in_match,
+            profile_completion,
+            no_of_photos,
+            miles_away,
+            user_id,
+            is_liked,
+            age
+        FROM
+            ml_data
+        """
+
+        df = pd.read_sql(query, engine)
+
+        print(f"Successfully fetched {len(df)} records from PostgreSQL")
+
+        bool_cols = ['is_job_matched', 'is_edu_matched', 'is_religion_match',
+                      'is_interested_in_match', 'is_liked']
+        for col in bool_cols:
+            if df[col].dtype == bool:
+                df[col] = df[col].astype(int)
+
+        return df
+
+    except Exception as e:
+        print(f"Error connecting to PostgreSQL database: {e}")
+        return None
+
+def preprocess_data(df, test_size=0.20, random_state=42):
+    """
+    Preprocess the dating app data for logistic regression
+    """
+    data = df.copy()
+
+    # data['compatibility_score'] = (
+    #     data['hobies_matched'] * 0.3 +
+    #     data['is_job_matched'] * 0.1 +
+    #     data['is_edu_matched'] * 0.1 +
+    #     data['is_religion_match'] * 0.2 +
+    #     data['is_interested_in_match'] * 0.3
+    # )
+
+    # data['miles_away_log'] = np.log1p(data['miles_away'])
+
+    # data['profile_quality'] = (data['profile_completion'] * 0.7 +
+    #                           data['no_of_photos'] * 30 * 0.3)
+
+    # data['interest_x_photos'] = data['is_interested_in_match'] * data['no_of_photos']
+    # data['hobbies_x_religion'] = data['hobies_matched'] * data['is_religion_match']
+
+    exclude_cols = ['id', 'user_id', 'is_liked']
+    feature_cols = [col for col in data.columns if col not in exclude_cols]
+    print(f"Feature columns: {feature_cols}")
+
+    X = data[feature_cols].values
+    y = data['is_liked'].values
+
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=test_size, random_state=random_state, stratify=y
+    )
+
+    scaler = StandardScaler()
+    X_train = scaler.fit_transform(X_train)
+    X_test = scaler.transform(X_test)
+
+    return X_train, X_test, y_train, y_test, scaler
+
+def transform_new_data(data, scaler):
+    """
+    Transform new data for prediction using the fitted scaler
+    """
+    # Convert to numpy array if it's a DataFrame
+    if isinstance(data, pd.DataFrame):
+        data = data.values
+
+    # Apply the same scaling used during training
+    scaled_data = scaler.transform(data)
+
+    return scaled_data

dating_model/setup.py

@@ -0,0 +1,19 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="dating_model",
+    version="0.1.0",
+    packages=find_packages(),
+    install_requires=[
+        "numpy>=1.26.4",
+        "pandas>=1.3.0",
+        "scikit-learn>=1.6.0",
+        "sqlalchemy>=1.4.0",
+        "joblib>=1.1.0",
+    ],
+    author="Jasif Shameem K",
+    author_email="jasifkolangath@gmail.com",
+    description="A package for dating app swipe prediction using logistic regression",
+    keywords="machine learning, dating app, prediction",
+    python_requires=">=3.7",
+)

dating_scaler.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:747889fe7e37089373a71fa93742fe88b04019a351f0cbeaecc8894765c09fe2
+size 815

requirements.txt

@@ -0,0 +1,4 @@
+gradio>=5.20.1
+joblib>=1.4.2
+scikit-learn>=1.6.1
+numpy>=1.26.4

utils.py

@@ -0,0 +1,8 @@
+from sklearn.preprocessing import StandardScaler
+
+
+def preprocess_features(features):
+  scaler = StandardScaler()
+  scaled_features = scaler.transform(features)
+
+  return scaled_features