用Numpy实现Sign函数

Sign函数可以表示为：$sign(x) = \begin{cases} 1 & x > 0 \\ 0 & x = 0 \\ -1 & x < 0 \end{cases}$

可以使用Numpy的where函数实现：

import numpy as np

def sign(x):
    return np.where(x > 0, 1, np.where(x == 0, 0, -1))

其中，np.where函数的第一个参数是条件，第二个参数是条件为True时的返回值，第三个参数是条件为False时的返回值。

相关问题

np.sign函数怎么用

np.sign函数是numpy库中的一个函数，其作用是返回输入数组中每个元素的符号。

使用方式如下：

import numpy as np

a = np.array([-2, 0, 3])
b = np.sign(a)

print(b)  # [-1  0  1]

在上面的例子中，我们首先导入了numpy库，然后创建了一个包含三个元素的一维数组a。接下来，我们使用np.sign函数对数组a中的每个元素进行符号判断，并将结果赋值给一个新的数组b。最后，我们打印出了数组b中的每个元素。

可以看到，np.sign函数返回的是一个新的数组，其中每个元素的值为其对应输入数组元素的符号。如果输入数组元素是正数，则返回1；如果输入数组元素是负数，则返回-1；如果输入数组元素是0，则返回0。

用numpy独立实现svm回归预测

好的，以下是用numpy独立实现svm回归预测的步骤：

1. 导入必要的库

import numpy as np

2. 定义SVM回归模型

class SVM:
    def __init__(self, C=1.0, kernel='linear', degree=3, gamma='scale', coef0=0.0):
        self.C = C  # 惩罚系数
        self.kernel = kernel  # 核函数类型
        self.degree = degree  # 多项式核函数的次数
        self.gamma = gamma  # 核函数的系数
        self.coef0 = coef0  # 独立项

    # 计算核函数
    def _kernel_function(self, X, Y):
        if self.kernel == 'linear':  # 线性核函数
            return np.dot(X, Y.T)
        elif self.kernel == 'poly':  # 多项式核函数
            return (self.gamma * np.dot(X, Y.T) + self.coef0) ** self.degree
        elif self.kernel == 'rbf':  # 高斯核函数
            if self.gamma == 'scale':
                gamma = 1 / (X.shape[1] * X.var())
            elif self.gamma == 'auto':
                gamma = 1 / X.shape[1]
            else:
                gamma = self.gamma
            return np.exp(-gamma * ((X[:, np.newaxis, :] - Y[np.newaxis, :, :]) ** 2).sum(axis=2))
        else:
            raise ValueError('Invalid kernel type.')

    # 计算损失函数
    def _loss_function(self, X, y, alpha, b):
        return 0.5 * np.dot(alpha * y, self._kernel_function(X, X)) - np.sum(alpha) + np.sum(alpha * y * b)

    # 计算预测值
    def _predict(self, X):
        return np.sign(np.dot(self.alpha * self.y, self._kernel_function(self.X, X)) + self.b)

    # 训练模型
    def fit(self, X, y, max_iter=100, tol=1e-3):
        self.X = X
        self.y = y
        self.alpha = np.zeros(X.shape[0])
        self.b = 0.0

        # 计算初始的b值
        b = np.mean(y - np.dot(self.alpha * y, self._kernel_function(X, X)))
        self.alpha = np.clip(self.alpha, 0, self.C)  # 将alpha限制在[0, C]之间

        for epoch in range(max_iter):
            alpha_old = np.copy(self.alpha)
            for i in range(X.shape[0]):
                Ei = self._predict(X[i]) - y[i]
                if (y[i] * Ei < -tol and self.alpha[i] < self.C) or (y[i] * Ei > tol and self.alpha[i] > 0):
                    j = np.random.choice(list(range(i)) + list(range(i + 1, X.shape[0])))  # 随机选择另一个样本
                    Ej = self._predict(X[j]) - y[j]

                    alpha_i_old, alpha_j_old = self.alpha[i], self.alpha[j]
                    if y[i] != y[j]:
                        L = max(0, self.alpha[j] - self.alpha[i])
                        H = min(self.C, self.C + self.alpha[j] - self.alpha[i])
                    else:
                        L = max(0, self.alpha[i] + self.alpha[j] - self.C)
                        H = min(self.C, self.alpha[i] + self.alpha[j])
                    if L == H:
                        continue

                    eta = 2 * self._kernel_function(X[i], X[j]) - self._kernel_function(X[i], X[i]) - self._kernel_function(X[j], X[j])
                    if eta >= 0:
                        continue

                    self.alpha[j] -= y[j] * (Ei - Ej) / eta
                    self.alpha[j] = np.clip(self.alpha[j], L, H)
                    self.alpha[i] += y[i] * y[j] * (alpha_j_old - self.alpha[j])

                    # 更新b值
                    b1 = b - Ei - y[i] * (self.alpha[i] - alpha_i_old) * self._kernel_function(X[i], X[i]) - y[j] * (self.alpha[j] - alpha_j_old) * self._kernel_function(X[i], X[j])
                    b2 = b - Ej - y[i] * (self.alpha[i] - alpha_i_old) * self._kernel_function(X[i], X[j]) - y[j] * (self.alpha[j] - alpha_j_old) * self._kernel_function(X[j], X[j])
                    if 0 < self.alpha[i] < self.C:
                        self.b = b1
                    elif 0 < self.alpha[j] < self.C:
                        self.b = b2
                    else:
                        self.b = (b1 + b2) / 2

            # 判断是否收敛
            if np.linalg.norm(self.alpha - alpha_old) < tol:
                break

        # 计算模型参数
        self.support_vectors = (self.alpha > 0)
        self.n_support_vectors = np.sum(self.support_vectors)
        self.w = np.dot(self.alpha * y, X)
        self.kernel_values = self._kernel_function(X[self.support_vectors], X[self.support_vectors])
        self.b = np.mean(y[self.support_vectors] - np.dot(self.alpha[self.support_vectors] * y[self.support_vectors], self.kernel_values))

    # 预测
    def predict(self, X):
        return self._predict(X)

3. 加载数据集

data = np.loadtxt('data.txt', delimiter=',')
X = data[:, :-1]
y = data[:, -1]

4. 划分训练集和测试集

n_samples = X.shape[0]
train_size = int(n_samples * 0.8)
indices = np.random.permutation(n_samples)
train_idx, test_idx = indices[:train_size], indices[train_size:]
X_train, X_test, y_train, y_test = X[train_idx], X[test_idx], y[train_idx], y[test_idx]

5. 训练模型

svm = SVM(C=1.0, kernel='linear')
svm.fit(X_train, y_train)

6. 预测并计算准确率

y_pred = svm.predict(X_test)
accuracy = np.mean(y_pred == y_test)
print('Accuracy:', accuracy)

这样就完成了用numpy独立实现svm回归预测的过程。