revert to last working

Author: TimotheeMathieu

sklearn_extra/robust/_robust_weighted_estimator_helper.pyx

@@ -1,159 +1,3 @@
-# cython: infer_types=True
-# Fast swap step in PAM algorithm for k_medoid.
-# Author: Timothée Mathieu
-# License: 3-clause BSD
-
-cimport cython
-import numpy as np
-cimport numpy as np
-
-from sklearn.utils.extmath import row_norms
-from cython cimport floating
-
-from libc.stdint cimport int32_t, int64_t
-# instead of int and long
-
-
-import sys
-from time import time
-
-from libc.math cimport exp, log, sqrt, pow, fabs
-cimport numpy as np
-from numpy.math cimport INFINITY
-
-
-# Modified from sklearn.cluster._k_means_fast.pyx
-np.import_array()
-
-cdef floating _euclidean_dense_dense(
-        floating* a,  # IN
-        floating* b,  # IN
-        int32_t n_features) nogil:
-    """Euclidean distance between a dense and b dense"""
-    cdef:
-        int32_t i
-        int32_t n = n_features // 4
-        int32_t rem = n_features % 4
-        floating result = 0
-
-    # We manually unroll the loop for better cache optimization.
-    for i in range(n):
-        result += ((a[0] - b[0]) * (a[0] - b[0])
-                  +(a[1] - b[1]) * (a[1] - b[1])
-                  +(a[2] - b[2]) * (a[2] - b[2])
-                  +(a[3] - b[3]) * (a[3] - b[3]))
-        a += 4; b += 4
-
-    for i in range(rem):
-        result += (a[i] - b[i]) * (a[i] - b[i])
-
-    return result
-
-
-
-cpdef np.ndarray[floating] _kmeans_loss(np.ndarray[floating, ndim=2, mode='c'] X,
-                                        int32_t[:] labels):
-    """Compute inertia
-
-    squared distancez between each sample and its assigned center.
-    """
-    if floating is float:
-        dtype = np.float32
-    elif floating is double:
-        dtype = np.double
-
-    cdef:
-        int32_t n_samples = X.shape[0]
-        int32_t n_features = X.shape[1]
-        int32_t i, j
-        int32_t n_classes = len(np.unique(labels))
-        np.ndarray[floating, ndim=2] centers = np.zeros([n_classes,
-                                                         n_features],
-                                                         dtype = dtype)
-        np.ndarray[np.int32] num_in_cluster = np.zeros(n_classes, dtype = np.int32)
-        np.ndarray[floating] inertias = np.zeros(n_samples, dtype = dtype)
-    for i in range(n_samples):
-        for j in range(n_features):
-            centers[labels[i], j] += X[i, j]
-        num_in_cluster[labels[i]] = num_in_cluster[labels[i]] + 1
-
-    for i in range(n_classes):
-        for j in range(n_features):
-            centers[i, j] /= num_in_cluster[i]
-
-    for i in range(n_samples):
-        j = labels[i]
-        inertias[i] = _euclidean_dense_dense(&X[i, 0], &centers[j, 0], n_features)
-    return inertias
-
-
-
-
-
-# Regression and Classification losses, from scikit-learn.
-
-
-
-
-# ----------------------------------------
-# Extension Types for Loss Functions
-# ----------------------------------------
-
-cdef class LossFunction:
-    """Base class for convex loss functions"""
-
-    cdef double loss(self, double p, double y) nogil:
-        """Evaluate the loss function.
-
-        Parameters
-        ----------
-        p : double
-            The prediction, p = w^T x
-        y : double
-            The true value (aka target)
-
-        Returns
-        -------
-        double
-            The loss evaluated at `p` and `y`.
-        """
-        return 0.
-
-    def py_dloss(self, double p, double y):
-        """Python version of `dloss` for testing.
-
-        Pytest needs a python function and can't use cdef functions.
-        """
-        return self.dloss(p, y)
-
-    def py_loss(self, double p, double y):
-        """Python version of `dloss` for testing.
-
-        Pytest needs a python function and can't use cdef functions.
-        """
-        return self.loss(p, y)
-
-
-    cdef double dloss(self, double p, double y) nogil:
-        """Evaluate the derivative of the loss function with respect to
-        the prediction `p`.
-
-        Parameters
-        ----------
-        p : double
-            The prediction, p = w^T x
-        y : double
-            The true value (aka target)
-        Returns
-        -------
-        double
-            The derivative of the loss function with regards to `p`.
-        """
-        return 0.
-
-
-cdef class Regression(LossFunction):
-    """Base class for loss functions for regression"""
 
     cdef double loss(self, double p, double y) nogil:
         return 0.
@@ -336,4 +180,4 @@ cdef class Huber(Regression):
             return -self.c
 
     def __reduce__(self):
-        return Huber, (self.c,)
+        return Huber, (self.c,)