upgini 1.2.156.dev4__tar.gz → 1.2.156.dev5__tar.gz

{upgini-1.2.156.dev4 → upgini-1.2.156.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: upgini
-Version: 1.2.156.dev4
+Version: 1.2.156.dev5
 Summary: Intelligent data search & enrichment for Machine Learning
 Project-URL: Bug Reports, https://github.com/upgini/upgini/issues
 Project-URL: Homepage, https://upgini.com/

upgini-1.2.156.dev5/src/upgini/__about__.py

@@ -0,0 +1 @@
+__version__ = "1.2.156.dev5"

{upgini-1.2.156.dev4 → upgini-1.2.156.dev5}/src/upgini/autofe/binary.py

@@ -140,23 +140,120 @@ class Distance(PandasOperator):
     is_symmetrical: bool = True
     has_symmetry_importance: bool = True
 
+    def _to_float_vector(self, value) -> Optional[np.ndarray]:
+        if value is None or (isinstance(value, float) and np.isnan(value)):
+            return None
+        return np.atleast_1d(np.asarray(value, dtype=np.float64))
+
+    def _stack_vectors(self, arr: np.ndarray, indices: np.ndarray) -> Optional[np.ndarray]:
+        try:
+            stacked = np.vstack(arr[indices])
+        except (ValueError, TypeError):
+            return None
+        if stacked.ndim != 2 or stacked.shape[1] == 0:
+            return None
+        if stacked.dtype != np.float64:
+            stacked = stacked.astype(np.float64, copy=False)
+        return stacked
+
+    def _cosine_distance_stacked(self, left_mat: np.ndarray, right_mat: np.ndarray) -> np.ndarray:
+        if left_mat.shape != right_mat.shape:
+            raise ValueError("Left and right matrices must have the same shape")
+        dots = np.sum(left_mat * right_mat, axis=1)
+        denom = np.sqrt(np.sum(left_mat * left_mat, axis=1)) * np.sqrt(np.sum(right_mat * right_mat, axis=1))
+        results = np.full(len(left_mat), np.nan, dtype=np.float64)
+        valid = denom > 0
+        results[valid] = 1 - dots[valid] / denom[valid]
+        return results
+
+    def _try_fast_distance(
+        self, left_arr: np.ndarray, right_arr: np.ndarray, row_present: np.ndarray, n: int
+    ) -> Optional[np.ndarray]:
+        valid_idx = np.flatnonzero(row_present)
+        if len(valid_idx) == 0:
+            return None
+
+        left_mat = self._stack_vectors(left_arr, valid_idx)
+        right_mat = self._stack_vectors(right_arr, valid_idx)
+        if left_mat is None or right_mat is None:
+            return None
+
+        stacked_results = self._cosine_distance_stacked(left_mat, right_mat)
+        if row_present.all():
+            return stacked_results
+
+        results = np.full(n, np.nan, dtype=np.float64)
+        results[valid_idx] = stacked_results
+        return results
+
+    def _parse_vectors(self, left_arr: np.ndarray, right_arr: np.ndarray) -> tuple[list, list, np.ndarray]:
+        n = len(left_arr)
+        left_vecs: list[Optional[np.ndarray]] = [None] * n
+        right_vecs: list[Optional[np.ndarray]] = [None] * n
+        row_valid = np.zeros(n, dtype=bool)
+        for i, (left_value, right_value) in enumerate(zip(left_arr, right_arr)):
+            left_vec = self._to_float_vector(left_value)
+            right_vec = self._to_float_vector(right_value)
+            left_vecs[i] = left_vec
+            right_vecs[i] = right_vec
+            if left_vec is not None and right_vec is not None and left_vec.size > 0 and right_vec.size > 0:
+                row_valid[i] = True
+        return left_vecs, right_vecs, row_valid
+
+    def _masked_cosine_distance(
+        self, left_mat: np.ndarray, right_mat: np.ndarray, row_valid: np.ndarray
+    ) -> np.ndarray:
+        results = self._cosine_distance_stacked(left_mat, right_mat)
+        if len(results) == len(row_valid):
+            results[~row_valid] = np.nan
+        return results
+
+    def _calculate_rowwise(
+        self, results: np.ndarray, indices: np.ndarray, left_vecs: list, right_vecs: list
+    ) -> None:
+        for index in indices:
+            left_vec = left_vecs[index]
+            right_vec = right_vecs[index]
+            dot = np.sum(left_vec * right_vec)
+            denom = np.sqrt(np.sum(left_vec * left_vec)) * np.sqrt(np.sum(right_vec * right_vec))
+            if denom != 0:
+                results[index] = 1 - dot / denom
+
+    def _calculate_fallback_distance(
+        self, left_arr: np.ndarray, right_arr: np.ndarray, n: int, index: pd.Index
+    ) -> pd.Series:
+        results = np.full(n, np.nan, dtype=np.float64)
+        left_vecs, right_vecs, row_valid = self._parse_vectors(left_arr, right_arr)
+        if not row_valid.any():
+            return pd.Series(results, index=index, dtype=np.float64)
+
+        valid_idx = np.flatnonzero(row_valid)
+        dim = left_vecs[valid_idx[0]].size
+        if not all(left_vecs[i].size == dim and right_vecs[i].size == dim for i in valid_idx):
+            self._calculate_rowwise(results, valid_idx, left_vecs, right_vecs)
+            return pd.Series(results, index=index, dtype=np.float64)
+
+        left_mat = np.zeros((n, dim), dtype=np.float64)
+        right_mat = np.zeros((n, dim), dtype=np.float64)
+        left_mat[valid_idx] = np.stack([left_vecs[i] for i in valid_idx])
+        right_mat[valid_idx] = np.stack([right_vecs[i] for i in valid_idx])
+
+        return pd.Series(self._masked_cosine_distance(left_mat, right_mat, row_valid), index=index, dtype=np.float64)
+
     def calculate_binary(self, left: pd.Series, right: pd.Series) -> pd.Series:
-        return pd.Series(
-            1 - self.__dot(left, right) / (self.__norm(left) * self.__norm(right)), index=left.index
-        ).astype(np.float64)
-
-    # row-wise dot product, handling None values
-    def __dot(self, left: pd.Series, right: pd.Series) -> pd.Series:
-        left = left.apply(lambda x: np.array(x).astype(np.float64))
-        right = right.apply(lambda x: np.array(x).astype(np.float64))
-        res = (left.dropna() * right.dropna()).apply(np.sum)
-        res = res.reindex(left.index.union(right.index))
-        return res
-
-    # Calculate the norm of a vector, handling None values
-    def __norm(self, vector: pd.Series) -> pd.Series:
-        vector = vector.fillna(np.nan)
-        return np.sqrt(self.__dot(vector, vector))
+        n = len(left)
+        if n == 0:
+            return pd.Series(np.full(n, np.nan), index=left.index, dtype=np.float64)
+
+        row_present = left.notna().to_numpy() & right.notna().to_numpy()
+        left_arr = left.to_numpy()
+        right_arr = right.to_numpy()
+
+        fast_results = self._try_fast_distance(left_arr, right_arr, row_present, n)
+        if fast_results is not None:
+            return pd.Series(fast_results, index=left.index, dtype=np.float64)
+
+        return self._calculate_fallback_distance(left_arr, right_arr, n, left.index)
 
 
 # Left for backward compatibility

upgini-1.2.156.dev4/src/upgini/__about__.py

@@ -1 +0,0 @@
-__version__ = "1.2.156.dev4"