张开放

『自己的工作3』梯度下降实现SVM多分类+最详细的数学推导+Python实战(鸢尾花数据集)！

梯度下降实现SVM多分类+最详细的数学推导+Python实战(鸢尾花数据集)！

文章目录

一. SVM梯度公式详细推导

1.1. SVM多分类模型
1.2. SVM多分类梯度公式推导
1.3. SVM多分类算法优化过程

二. Python代码实战

2.1. 鸢尾花数据集介绍
2.2. Python代码实现SVM多分类
2.3. 程序最终运行结果

三. 随机梯度下降实现
补充：python中读取文件txt文件的几种方式
创作不易，欢迎点赞转发！

一. SVM梯度公式详细推导

支持向量机(Support Vector Machine, SVM)的基本模型是在特征空间上找到最佳的分离超平面使得训练集上正负样本间隔最大。SVM的目标是寻找一个最优化超平面在空间中分割两类数据，这个最优化超平面需要满足的条件是：离其最近的点到其的距离最大化，这些点被称为支持向量。SVM是用来解决二分类问题的有监督学习算法，同时它可以通过one-vs-all策略应用到多分类问题中。本文主要介绍如何使用梯度下降法对SVM多分类问题进行优化。

1.1. SVM多分类模型

假设数据集 $\mathbf{X} \in \mathrm{R}^{k \times n}$ ， $n$ 为训练样本的个数， $k$ 为每个样本的维度。另外注意：下面使用的是L2-SVM！
$\begin{aligned} \mathcal{L}(\mathbf{\boldsymbol w_{c}}, b_{c}) &=\sum_{c}^{C}\left[\frac{1}{2}\boldsymbol w_{c}^{T} \boldsymbol w_{c}+\lambda \sum_{i}^{N} \max \left\{0,1-y_{i}^{c}\left(\boldsymbol w_{c}^{T} \boldsymbol x_{i}+b_{c}\right)\right\}^{2}\right] \\ &=\frac{1}{2}\sum_{c}^{C} \boldsymbol w_{c}^{T} \boldsymbol w_{c}+\lambda \sum_{c}^{C} \sum_{i}^{N} \max \left\{0,1-y_{i}^{c}\left(\boldsymbol w_{c}^{T} \boldsymbol x_{i}+b_{c}\right)\right\}^2 \tag{1} \end{aligned}$

1.2. SVM多分类梯度公式推导

首先，当 $1-y_{i}\left(\boldsymbol w^{T} \boldsymbol x_{i}+b\right)<0$ 的样本，此时相当于分类正确的情况，不需要加上 Hinge-Loss，因此我们有如下：
$\begin{aligned} \mathcal{L}(\mathbf{\boldsymbol w_{c}}, b_{c}) = \frac{1}{2}\sum_{c}^{C} \boldsymbol w_{c}^{T} \boldsymbol w_{c}=\operatorname{tr}\left(\mathbf{W}^{\mathrm{T}} \mathbf{W}\right) \tag{2} \end{aligned}$ $\begin{aligned} \frac{\partial \mathcal{L}(\mathbf{\boldsymbol w_{c}}, b_{c})}{\partial \boldsymbol w_{c}} =\boldsymbol w_{c} \tag{3} \end{aligned}$
其次，当 $1-y_{i}\left(\boldsymbol w^{T} \boldsymbol x_{i}+b\right)>0$ 的样本，此时相当于分类不正确的情况，需要加上 Hinge-Loss，因此我们有如下：
$\begin{aligned} \mathcal{L}(\mathbf{\boldsymbol w_{c}}, b_{c}) &=\sum_{c}^{C}\left[\frac{1}{2}\boldsymbol w_{c}^{T} \boldsymbol w_{c}+\lambda \sum_{i}^{N} \max \left\{0,1-y_{i}^{c}\left(\boldsymbol w_{c}^{T} \boldsymbol x_{i}+b_{c}\right)\right\}^{2}\right] \\ &=\frac{1}{2}\sum_{c}^{C} \boldsymbol w_{c}^{T} \boldsymbol w_{c}+\lambda \sum_{c}^{C} \sum_{i}^{N}\left\|1-y_{i}^{c}\left(\boldsymbol w_{c}^{T} x_{i}+b_{c}\right)\right\|^{2} \\ &=\frac{1}{2} \sum_{c}^{C} \boldsymbol w_{c}^{T} \boldsymbol w_{c}+\lambda \sum_{c}^{C} \sum_{i}^{N}\left[1+\left(\boldsymbol w_{c}^{T} \boldsymbol x_{i}+b_{c}\right)^{2}-2 y_{i}^{c}\left(\boldsymbol w_{c}^{T} \boldsymbol x_{i}+b_{c}\right)\right] \\& =\frac{1}{2}\sum_{c} \boldsymbol w_{c}^{T} \boldsymbol w_{c}+\lambda \sum_{c=1}^{C} \sum_{i=1}^{N}\left[1+\boldsymbol w_{c}^{T} \boldsymbol x_{i} \boldsymbol x_{i}^{T} \boldsymbol w_{c}+b_{c}^{2}+2 \boldsymbol w_{c}^{T} \boldsymbol x_{i} b_{c}-2 y_{i}^{c} \boldsymbol w_{c}^{T} \boldsymbol x_{i}-2 y_{i}^{c} b_{c}\right] \\&=\frac{1}{2}\sum_{c} \boldsymbol w_{c}^{T} \boldsymbol w_{c}+\lambda \sum_{c=1}^{c}\left[n\left(1+b_{c}^{2}\right)+\boldsymbol w_{c}^{T}\left(\sum_{i=1}^{N}\boldsymbol x_{i}\boldsymbol x_{i}^{T}\right) \boldsymbol w_{c}+2 b_{c} \boldsymbol w_{c}^{T}\left(\sum_{i=1}^{N} \boldsymbol x_{i}\right)-2 \boldsymbol w_{c}^{T}\left(\sum_{i=1}^{N} \boldsymbol x_{i} y_{i}^{c}\right)-2\left(\sum_{i=1}^{N} y_{i}^{c}\right) b_{c}\right] \tag{4} \end{aligned}$

然后，整理上面可以得到：
$\begin{aligned} \mathcal{L}(\mathbf{\boldsymbol w_{c}}, b_{c}) &= \frac{1}{2}\sum_{i}\boldsymbol w_{c}^{T} \boldsymbol w_{c}+\lambda \sum_{i}\left[n\left(1+b_{c}^{2}\right)+\boldsymbol w_{c}^{T} \mathbf{X} \mathbf{X}^{\mathrm{T}} \boldsymbol w_{c}+2 b_{c} \boldsymbol w_{c}^{T} \mathbf{X} \mathbf{E}-2 \boldsymbol w_{c}^{T} \mathbf{X} \mathbf{y}_{c}-2 b_{c} \mathbf{E}^{T} \mathbf{y}_{c}\right] \tag{5} \end{aligned}$

此外，上述公式 $(5)$ 还可以继续化简，这里只是提供一个思路！
$\begin{aligned} \mathcal{L}(\mathbf{\mathbf{W}}, \mathbf{b}) =\frac{1}{2}\operatorname{tr}\left(\mathbf{W}^{\mathrm{T}} \mathbf{W}\right)+\lambda\left[n\left(c+\mathbf{b}^{\mathrm{T}} \mathbf{b}\right)+\operatorname{tr}\left(\mathbf{W}^{\mathrm{T}} \mathbf{X} \mathbf{X}^{\mathrm{T}} \mathbf{W}\right)+2 \mathbf{b}^{\mathrm{T}} \mathbf{W}^{\mathrm{T}} \mathbf{X} \mathbf{E}-2 \operatorname{tr}\left(\mathbf{W}^{\mathrm{T}} \mathbf{X} \mathbf{Y}^{\mathrm{T}}\right)-2 \mathbf{b}^{\mathrm{T}} \mathbf{Y} \mathbf{E}\right] \tag{6} \end{aligned}$
目标函数 $(5)$ 分别对 $\boldsymbol w_{c}$ 和 $b_c$ 求偏导数，可以得到如下：
$\frac{\partial \mathcal{L}(\mathbf{\boldsymbol w_{c}}, b_{c})}{\partial \boldsymbol w_{c}} = \boldsymbol w_{c}+2 \mathbf{X} \mathbf{X}^{\mathrm{T}} \boldsymbol w_{c}+2 \mathbf{X} \mathbf{E} b_{c}-2 \mathbf{X}{\mathbf y}_{c}\tag{7}$ $\frac{\partial \mathcal{L}(\mathbf{\boldsymbol w_{c}}, b_{c})}{\partial b_{c}} = 2 n b_{c}-2{\mathbf y}_{c}^{T} \mathbf{E}\tag{8}$

${\mathbf{X} }_{k \times n}=\left[\begin{array}{cccc}{ x_{1}^{(1)}} & { x_{1}^{(2)}} & {.} & { x_{1}^{(n)}} \\ {.} & {.} & {.} & {.} \\ {.} & {.} & {.} & {.} \\ {.} & {.} & {.} & {.} \\ { x_{k}^{(1)}} & { x_{k}^{(2)}} & {.} & { x_{k}^{(n)}}\end{array}\right]_{k \times n}$	${\mathbf{Y}}_{{C \times n}}=\left[\begin{array}{cccc}{y_{1}^{(1)}} & {y_{2}^{(1)}} & {.} & {y_{n}^{(1)}} \\ {\cdot} & {\cdot} & {\cdot} & {\cdot} \\ {\cdot} & {\cdot} & {\cdot} & {\cdot} \\ {y_{1}^{(C)}} & {y_{2}^{(C)}} & {\cdot} & {y_{\mathrm{n}}^{(C)}}\end{array}\right]_{{C \times n}}$	$\mathbf{E}=\left[\begin{array}{l}{1} \\ {\cdot} \\ {\cdot} \\ {1}\end{array}\right]_{n \times 1}$
$\mathbf{W}_{k \times C}=\left[\begin{array}{lll}{w_{1}^{(1)}} & {w_{1}^{(2)}} & {.} & {w_{1}^{(C)}} \\ {.} & {.} & {.} & {.} \\ {.} & {.} & {.} & {.} \\ {w_{k}^{(1)}} & {w_{k}^{(2)}} & {.} & {w_{k}^{(C)}}\end{array}\right]_{k \times C}$	$\mathbf{b}=\left[\begin{array}{l}{b_{1}} \\ {.} \\ {.} \\ {b_{C}}\end{array}\right]_{C \times 1}$	$\boldsymbol{y}_{\mathrm{c}}=\left[\begin{array}{c}{y_{1}^{(c)}} \\ {\cdot} \\ {\cdot} \\ {y_{n}^{(c)}}\end{array}\right]_{n \times 1}$

1.3. SVM多分类算法优化过程

整体迭代过程非常容易理解，主要分为以下两个模块(具体的过程看2.2章节的代码实现)：

① 如果进来的样本不满足条件 $1-y_{i}\left(\boldsymbol w^{T} \boldsymbol x_{i}+b\right)>0,$ 那么将尽可能能往满足条件的方向优化(此时使用 Hinge-Loss在SVM的原问题空间对问题进行优化)。

② 如果进来的样本符条件 $1-y_{i}\left(\boldsymbol w^{T} \boldsymbol x_{i}+b\right)<0,$ 那么参数保持不变。

二. Python代码实战

2.1. 鸢尾花数据集介绍

Iris 鸢尾花数据集包含3 类共 150 条记录，每类各 50 个数据，每条记录都有 4 项特征：花萼长度、花萼宽度、花瓣长度、花瓣宽度，可以通过这4个特征预测鸢尾花卉属于(iris-setosa, iris-versicolour, iris-virginica)中的哪一品种。

这里就以鸢尾花数据集为例one.txt：

5.1,3.5,1.4,0.2,Iris-setosa
4.9,3.0,1.4,0.2,Iris-setosa
4.7,3.2,1.3,0.2,Iris-setosa
4.6,3.1,1.5,0.2,Iris-setosa
5.0,3.6,1.4,0.2,Iris-setosa
5.4,3.9,1.7,0.4,Iris-setosa
4.6,3.4,1.4,0.3,Iris-setosa
5.0,3.4,1.5,0.2,Iris-setosa
4.4,2.9,1.4,0.2,Iris-setosa
4.9,3.1,1.5,0.1,Iris-setosa
5.4,3.7,1.5,0.2,Iris-setosa
4.8,3.4,1.6,0.2,Iris-setosa
4.8,3.0,1.4,0.1,Iris-setosa
4.3,3.0,1.1,0.1,Iris-setosa
5.8,4.0,1.2,0.2,Iris-setosa
5.7,4.4,1.5,0.4,Iris-setosa
5.4,3.9,1.3,0.4,Iris-setosa
5.1,3.5,1.4,0.3,Iris-setosa
5.7,3.8,1.7,0.3,Iris-setosa
5.1,3.8,1.5,0.3,Iris-setosa
5.4,3.4,1.7,0.2,Iris-setosa
5.1,3.7,1.5,0.4,Iris-setosa
4.6,3.6,1.0,0.2,Iris-setosa
5.1,3.3,1.7,0.5,Iris-setosa
4.8,3.4,1.9,0.2,Iris-setosa
5.0,3.0,1.6,0.2,Iris-setosa
5.0,3.4,1.6,0.4,Iris-setosa
5.2,3.5,1.5,0.2,Iris-setosa
5.2,3.4,1.4,0.2,Iris-setosa
4.7,3.2,1.6,0.2,Iris-setosa
4.8,3.1,1.6,0.2,Iris-setosa
5.4,3.4,1.5,0.4,Iris-setosa
5.2,4.1,1.5,0.1,Iris-setosa
5.5,4.2,1.4,0.2,Iris-setosa
4.9,3.1,1.5,0.1,Iris-setosa
5.0,3.2,1.2,0.2,Iris-setosa
5.5,3.5,1.3,0.2,Iris-setosa
4.9,3.1,1.5,0.1,Iris-setosa
4.4,3.0,1.3,0.2,Iris-setosa
5.1,3.4,1.5,0.2,Iris-setosa
5.0,3.5,1.3,0.3,Iris-setosa
4.5,2.3,1.3,0.3,Iris-setosa
4.4,3.2,1.3,0.2,Iris-setosa
5.0,3.5,1.6,0.6,Iris-setosa
5.1,3.8,1.9,0.4,Iris-setosa
4.8,3.0,1.4,0.3,Iris-setosa
5.1,3.8,1.6,0.2,Iris-setosa
4.6,3.2,1.4,0.2,Iris-setosa
5.3,3.7,1.5,0.2,Iris-setosa
5.0,3.3,1.4,0.2,Iris-setosa
7.0,3.2,4.7,1.4,Iris-versicolor
6.4,3.2,4.5,1.5,Iris-versicolor
6.9,3.1,4.9,1.5,Iris-versicolor
5.5,2.3,4.0,1.3,Iris-versicolor
6.5,2.8,4.6,1.5,Iris-versicolor
5.7,2.8,4.5,1.3,Iris-versicolor
6.3,3.3,4.7,1.6,Iris-versicolor
4.9,2.4,3.3,1.0,Iris-versicolor
6.6,2.9,4.6,1.3,Iris-versicolor
5.2,2.7,3.9,1.4,Iris-versicolor
5.0,2.0,3.5,1.0,Iris-versicolor
5.9,3.0,4.2,1.5,Iris-versicolor
6.0,2.2,4.0,1.0,Iris-versicolor
6.1,2.9,4.7,1.4,Iris-versicolor
5.6,2.9,3.6,1.3,Iris-versicolor
6.7,3.1,4.4,1.4,Iris-versicolor
5.6,3.0,4.5,1.5,Iris-versicolor
5.8,2.7,4.1,1.0,Iris-versicolor
6.2,2.2,4.5,1.5,Iris-versicolor
5.6,2.5,3.9,1.1,Iris-versicolor
5.9,3.2,4.8,1.8,Iris-versicolor
6.1,2.8,4.0,1.3,Iris-versicolor
6.3,2.5,4.9,1.5,Iris-versicolor
6.1,2.8,4.7,1.2,Iris-versicolor
6.4,2.9,4.3,1.3,Iris-versicolor
6.6,3.0,4.4,1.4,Iris-versicolor
6.8,2.8,4.8,1.4,Iris-versicolor
6.7,3.0,5.0,1.7,Iris-versicolor
6.0,2.9,4.5,1.5,Iris-versicolor
5.7,2.6,3.5,1.0,Iris-versicolor
5.5,2.4,3.8,1.1,Iris-versicolor
5.5,2.4,3.7,1.0,Iris-versicolor
5.8,2.7,3.9,1.2,Iris-versicolor
6.0,2.7,5.1,1.6,Iris-versicolor
5.4,3.0,4.5,1.5,Iris-versicolor
6.0,3.4,4.5,1.6,Iris-versicolor
6.7,3.1,4.7,1.5,Iris-versicolor
6.3,2.3,4.4,1.3,Iris-versicolor
5.6,3.0,4.1,1.3,Iris-versicolor
5.5,2.5,4.0,1.3,Iris-versicolor
5.5,2.6,4.4,1.2,Iris-versicolor
6.1,3.0,4.6,1.4,Iris-versicolor
5.8,2.6,4.0,1.2,Iris-versicolor
5.0,2.3,3.3,1.0,Iris-versicolor
5.6,2.7,4.2,1.3,Iris-versicolor
5.7,3.0,4.2,1.2,Iris-versicolor
5.7,2.9,4.2,1.3,Iris-versicolor
6.2,2.9,4.3,1.3,Iris-versicolor
5.1,2.5,3.0,1.1,Iris-versicolor
5.7,2.8,4.1,1.3,Iris-versicolor
6.3,3.3,6.0,2.5,Iris-virginica
5.8,2.7,5.1,1.9,Iris-virginica
7.1,3.0,5.9,2.1,Iris-virginica
6.3,2.9,5.6,1.8,Iris-virginica
6.5,3.0,5.8,2.2,Iris-virginica
7.6,3.0,6.6,2.1,Iris-virginica
4.9,2.5,4.5,1.7,Iris-virginica
7.3,2.9,6.3,1.8,Iris-virginica
6.7,2.5,5.8,1.8,Iris-virginica
7.2,3.6,6.1,2.5,Iris-virginica
6.5,3.2,5.1,2.0,Iris-virginica
6.4,2.7,5.3,1.9,Iris-virginica
6.8,3.0,5.5,2.1,Iris-virginica
5.7,2.5,5.0,2.0,Iris-virginica
5.8,2.8,5.1,2.4,Iris-virginica
6.4,3.2,5.3,2.3,Iris-virginica
6.5,3.0,5.5,1.8,Iris-virginica
7.7,3.8,6.7,2.2,Iris-virginica
7.7,2.6,6.9,2.3,Iris-virginica
6.0,2.2,5.0,1.5,Iris-virginica
6.9,3.2,5.7,2.3,Iris-virginica
5.6,2.8,4.9,2.0,Iris-virginica
7.7,2.8,6.7,2.0,Iris-virginica
6.3,2.7,4.9,1.8,Iris-virginica
6.7,3.3,5.7,2.1,Iris-virginica
7.2,3.2,6.0,1.8,Iris-virginica
6.2,2.8,4.8,1.8,Iris-virginica
6.1,3.0,4.9,1.8,Iris-virginica
6.4,2.8,5.6,2.1,Iris-virginica
7.2,3.0,5.8,1.6,Iris-virginica
7.4,2.8,6.1,1.9,Iris-virginica
7.9,3.8,6.4,2.0,Iris-virginica
6.4,2.8,5.6,2.2,Iris-virginica
6.3,2.8,5.1,1.5,Iris-virginica
6.1,2.6,5.6,1.4,Iris-virginica
7.7,3.0,6.1,2.3,Iris-virginica
6.3,3.4,5.6,2.4,Iris-virginica
6.4,3.1,5.5,1.8,Iris-virginica
6.0,3.0,4.8,1.8,Iris-virginica
6.9,3.1,5.4,2.1,Iris-virginica
6.7,3.1,5.6,2.4,Iris-virginica
6.9,3.1,5.1,2.3,Iris-virginica
5.8,2.7,5.1,1.9,Iris-virginica
6.8,3.2,5.9,2.3,Iris-virginica
6.7,3.3,5.7,2.5,Iris-virginica
6.7,3.0,5.2,2.3,Iris-virginica
6.3,2.5,5.0,1.9,Iris-virginica
6.5,3.0,5.2,2.0,Iris-virginica
6.2,3.4,5.4,2.3,Iris-virginica
5.9,3.0,5.1,1.8,Iris-virginica

2.2. Python代码实现SVM多分类

程序代码如下：

import numpy as np

batchsz = 150

def obtain_w_via_gradient_descent(x, c, y, penalty_c, threshold = 1e-19, learn_rate = 1e-4):
    """ 利用梯度下降法求解如下的SVM问题：min 1/2 * w^T * w + C * Σ_i=1:n（max(0, 1 - y_i * (w^T * x_i + b))）
    :param x: 训练样本 x = [x_1, x_2, ..., x_i]
    :param c: 类别数
    :param y: 样本标签 y = [y_1, y_2, ..., y_c]
    :param threshold: 梯度下降停止阈值
    """
    data_num = np.shape(x)[1]
    feature_dim = np.shape(x)[0]
    w = np.ones([feature_dim, c], dtype=np.float32)
    b = np.ones([c, 1], dtype=np.float32)
    dl_dw = np.zeros([feature_dim, c], dtype=np.float)
    dl_db = np.zeros([c, 1], dtype=np.float)
    it = 1
    th = 0.1
    while it < 60000 and th > threshold:
        a = np.tile(b, [1, data_num])
        ksi = (np.transpose(w) @ x + np.tile(b, [1, data_num])) * y
        index_martix = ksi < 1

        for class_num in range(c):
            index_vector = index_martix[class_num, :]

            if True in index_vector:
                x_c = x[:, index_vector]

                data_num_c = np.shape(x_c)[1]
                e = np.ones([data_num_c, 1], dtype=np.float)
                y_c = np.reshape(y[class_num, index_vector], [data_num_c, 1])
                w_c = np.reshape(w[:, class_num], [feature_dim, 1])
                b_c = b[class_num]

                dl_dw[:, class_num] = (w_c + 2 * penalty_c * (x_c @ np.transpose(x_c) @ w_c +
                                                              x_c @ e * b_c -
                                                              x_c @ y_c))[:, 0]
                dl_db[class_num, 0] = 2 * penalty_c * (b_c * data_num_c +
                                                       np.transpose(w_c) @ x_c @ e -
                                                       np.transpose(y_c) @ e)
            else:
                w_c = np.reshape(w[:, class_num], [feature_dim, 1])
                dl_dw[:, class_num] = w_c[:, 0]
                dl_db[class_num, 0] = 0

        w_ = w - learn_rate * (dl_dw / np.linalg.norm(dl_dw, ord=2))
        b_ = b - learn_rate * dl_db

        th = np.sum(np.square(w_ - w)) + np.sum(np.square(b_ - b))
        it = it + 1

        w = w_
        b = b_

        if it % 200 == 0:
            y_predict = np.transpose(w) @ x + np.tile(b, [1, data_num])
            correct_prediction = np.equal(np.argmax(y_predict, 0), np.argmax(y, 0))
            accuracy = np.mean(correct_prediction.astype(np.float))
            print("epoch:", it, "acc:", accuracy)

def iris_type(s):
    it = {b'Iris-setosa': 0, b'Iris-versicolor': 1, b'Iris-virginica': 2}    # b'Iris-virginica': 2
    return it[s]

def normalize_data(data):
    mean = np.mean(data, axis=0)
    std = np.std(data, axis=0)
    for i in range(data.shape[0]):
        data[i, :] = (data[i, :] - mean) / std
    return  data

def convert_to_one_hot(y, C):
    return np.eye(C)[y.reshape(-1)]

def main():
    data = np.loadtxt('./one.txt', dtype=float, delimiter=',', converters={4: iris_type})  #
    x = data[:, :4]
    x = normalize_data(x)     # 预处理数据
    y = data[:, 4]
    y = y.astype(np.int)
    y_onehot = convert_to_one_hot(y, 3)
    y_onehot[y_onehot == 0] = -1

    x = np.transpose(x)                         # k*n  k: 特征维度， n: 样本数
    y_onehot = np.transpose(y_onehot)           # c*n  c: 类别数，   n: 样本数
    w = np.array([[1, 1, 1], [1, 1, 1]])        # k*c  k: 特征维度,  c: 类别数
    b = np.array([[1],[1],[1]])                 # c*1  c: 类别数
    obtain_w_via_gradient_descent(x, 3, y_onehot, 0.5)

if __name__ == '__main__':
    main()

2.3. 程序最终运行结果

程序最终运行结果如下：

ssh://zhangkf@192.168.136.64:22/home/zhangkf/anaconda3/envs/py1/bin/python -u /home/zhangkf/johnCodes/TF1/svm_test/SVM_grad.py
epoch: 200 acc: 0.6666666666666666
epoch: 400 acc: 0.3333333333333333
epoch: 600 acc: 0.3333333333333333
epoch: 800 acc: 0.3333333333333333
epoch: 1000 acc: 0.3333333333333333
epoch: 1200 acc: 0.3333333333333333
epoch: 1400 acc: 0.3333333333333333
epoch: 1600 acc: 0.3333333333333333
epoch: 1800 acc: 0.3333333333333333
epoch: 2000 acc: 0.3333333333333333
epoch: 2200 acc: 0.3333333333333333
epoch: 2400 acc: 0.3333333333333333
epoch: 2600 acc: 0.34
epoch: 2800 acc: 0.34
epoch: 3000 acc: 0.36
epoch: 3200 acc: 0.36666666666666664
epoch: 3400 acc: 0.38
epoch: 3600 acc: 0.3933333333333333
epoch: 3800 acc: 0.4
epoch: 4000 acc: 0.4266666666666667
epoch: 4200 acc: 0.43333333333333335
epoch: 4400 acc: 0.47333333333333333
epoch: 4600 acc: 0.5
epoch: 4800 acc: 0.5066666666666667
epoch: 5000 acc: 0.52
epoch: 5200 acc: 0.52
epoch: 5400 acc: 0.52
epoch: 5600 acc: 0.54
epoch: 5800 acc: 0.5533333333333333
epoch: 6000 acc: 0.5733333333333334
epoch: 6200 acc: 0.58
epoch: 6400 acc: 0.58
epoch: 6600 acc: 0.58
epoch: 6800 acc: 0.5866666666666667
epoch: 7000 acc: 0.5866666666666667
epoch: 7200 acc: 0.5933333333333334
epoch: 7400 acc: 0.5933333333333334
epoch: 7600 acc: 0.6066666666666667
epoch: 7800 acc: 0.6066666666666667
epoch: 8000 acc: 0.6266666666666667
epoch: 8200 acc: 0.6333333333333333
epoch: 8400 acc: 0.64
epoch: 8600 acc: 0.64
epoch: 8800 acc: 0.6466666666666666
epoch: 9000 acc: 0.6533333333333333
epoch: 9200 acc: 0.66
epoch: 9400 acc: 0.66
epoch: 9600 acc: 0.66
epoch: 9800 acc: 0.66
epoch: 10000 acc: 0.6466666666666666
epoch: 10200 acc: 0.6533333333333333
epoch: 10400 acc: 0.6533333333333333
epoch: 10600 acc: 0.6533333333333333
epoch: 10800 acc: 0.6533333333333333
epoch: 11000 acc: 0.6533333333333333
epoch: 11200 acc: 0.6533333333333333
epoch: 11400 acc: 0.66
epoch: 11600 acc: 0.66
epoch: 11800 acc: 0.66
epoch: 12000 acc: 0.6666666666666666
epoch: 12200 acc: 0.6733333333333333
epoch: 12400 acc: 0.6866666666666666
epoch: 12600 acc: 0.6866666666666666
epoch: 12800 acc: 0.6866666666666666
epoch: 13000 acc: 0.6866666666666666
epoch: 13200 acc: 0.6866666666666666
epoch: 13400 acc: 0.6933333333333334
epoch: 13600 acc: 0.7133333333333334
epoch: 13800 acc: 0.72
epoch: 14000 acc: 0.7333333333333333
epoch: 14200 acc: 0.74
epoch: 14400 acc: 0.7466666666666667
epoch: 14600 acc: 0.7533333333333333
epoch: 14800 acc: 0.76
epoch: 15000 acc: 0.76
epoch: 15200 acc: 0.7666666666666667
epoch: 15400 acc: 0.7666666666666667
epoch: 15600 acc: 0.7666666666666667
epoch: 15800 acc: 0.7666666666666667
epoch: 16000 acc: 0.78
epoch: 16200 acc: 0.78
epoch: 16400 acc: 0.7866666666666666
epoch: 16600 acc: 0.7933333333333333
epoch: 16800 acc: 0.7933333333333333
epoch: 17000 acc: 0.7933333333333333
epoch: 17200 acc: 0.7933333333333333
epoch: 17400 acc: 0.8066666666666666
epoch: 17600 acc: 0.8066666666666666
epoch: 17800 acc: 0.82
epoch: 18000 acc: 0.8266666666666667
epoch: 18200 acc: 0.82
epoch: 18400 acc: 0.82
epoch: 18600 acc: 0.8266666666666667
epoch: 18800 acc: 0.8266666666666667
epoch: 19000 acc: 0.8266666666666667
epoch: 19200 acc: 0.8266666666666667
epoch: 19400 acc: 0.8333333333333334
epoch: 19600 acc: 0.8333333333333334
epoch: 19800 acc: 0.8333333333333334
epoch: 20000 acc: 0.8333333333333334
epoch: 20200 acc: 0.8333333333333334
epoch: 20400 acc: 0.8466666666666667
epoch: 20600 acc: 0.8533333333333334
epoch: 20800 acc: 0.86
epoch: 21000 acc: 0.8666666666666667
epoch: 21200 acc: 0.8666666666666667
epoch: 21400 acc: 0.8666666666666667
epoch: 21600 acc: 0.8666666666666667
epoch: 21800 acc: 0.8666666666666667
epoch: 22000 acc: 0.8666666666666667
epoch: 22200 acc: 0.8666666666666667
epoch: 22400 acc: 0.8666666666666667
epoch: 22600 acc: 0.8666666666666667
epoch: 22800 acc: 0.8666666666666667
epoch: 23000 acc: 0.8666666666666667
epoch: 23200 acc: 0.8666666666666667
epoch: 23400 acc: 0.8666666666666667
epoch: 23600 acc: 0.8666666666666667
epoch: 23800 acc: 0.8666666666666667
epoch: 24000 acc: 0.8666666666666667
epoch: 24200 acc: 0.8666666666666667
epoch: 24400 acc: 0.8666666666666667
epoch: 24600 acc: 0.8666666666666667
epoch: 24800 acc: 0.8666666666666667
epoch: 25000 acc: 0.8666666666666667
epoch: 25200 acc: 0.8666666666666667
epoch: 25400 acc: 0.8666666666666667
epoch: 25600 acc: 0.8666666666666667
epoch: 25800 acc: 0.8666666666666667
epoch: 26000 acc: 0.8666666666666667
epoch: 26200 acc: 0.8666666666666667
epoch: 26400 acc: 0.8666666666666667
epoch: 26600 acc: 0.86
epoch: 26800 acc: 0.86
epoch: 27000 acc: 0.86
epoch: 27200 acc: 0.86
epoch: 27400 acc: 0.86
epoch: 27600 acc: 0.86
epoch: 27800 acc: 0.86
epoch: 28000 acc: 0.86
epoch: 28200 acc: 0.8666666666666667
epoch: 28400 acc: 0.86
epoch: 28600 acc: 0.86
epoch: 28800 acc: 0.86
epoch: 29000 acc: 0.86
epoch: 29200 acc: 0.86
epoch: 29400 acc: 0.86
epoch: 29600 acc: 0.86
epoch: 29800 acc: 0.86
epoch: 30000 acc: 0.8533333333333334
epoch: 30200 acc: 0.8533333333333334
epoch: 30400 acc: 0.86
epoch: 30600 acc: 0.86
epoch: 30800 acc: 0.8666666666666667
epoch: 31000 acc: 0.8666666666666667
epoch: 31200 acc: 0.8666666666666667
epoch: 31400 acc: 0.8666666666666667
epoch: 31600 acc: 0.86
epoch: 31800 acc: 0.86
epoch: 32000 acc: 0.86
epoch: 32200 acc: 0.86
epoch: 32400 acc: 0.86
epoch: 32600 acc: 0.86
epoch: 32800 acc: 0.86
epoch: 33000 acc: 0.86
epoch: 33200 acc: 0.86
epoch: 33400 acc: 0.86
epoch: 33600 acc: 0.86
epoch: 33800 acc: 0.86
epoch: 34000 acc: 0.8666666666666667
epoch: 34200 acc: 0.8666666666666667
epoch: 34400 acc: 0.8666666666666667
epoch: 34600 acc: 0.8666666666666667
epoch: 34800 acc: 0.8666666666666667
epoch: 35000 acc: 0.8666666666666667
epoch: 35200 acc: 0.8866666666666667
epoch: 35400 acc: 0.8866666666666667
epoch: 35600 acc: 0.8933333333333333
epoch: 35800 acc: 0.9
epoch: 36000 acc: 0.9
epoch: 36200 acc: 0.9
epoch: 36400 acc: 0.9
epoch: 36600 acc: 0.9
epoch: 36800 acc: 0.9
epoch: 37000 acc: 0.9
epoch: 37200 acc: 0.9
epoch: 37400 acc: 0.9
epoch: 37600 acc: 0.9
epoch: 37800 acc: 0.9
epoch: 38000 acc: 0.9
epoch: 38200 acc: 0.9066666666666666
epoch: 38400 acc: 0.9066666666666666
epoch: 38600 acc: 0.9133333333333333
epoch: 38800 acc: 0.9133333333333333
epoch: 39000 acc: 0.9133333333333333
epoch: 39200 acc: 0.9133333333333333
epoch: 39400 acc: 0.9133333333333333
epoch: 39600 acc: 0.9133333333333333
epoch: 39800 acc: 0.9133333333333333
epoch: 40000 acc: 0.9133333333333333
epoch: 40200 acc: 0.9133333333333333
epoch: 40400 acc: 0.9133333333333333
epoch: 40600 acc: 0.9133333333333333
epoch: 40800 acc: 0.9133333333333333
epoch: 41000 acc: 0.9133333333333333
epoch: 41200 acc: 0.9133333333333333
epoch: 41400 acc: 0.9133333333333333
epoch: 41600 acc: 0.9266666666666666
epoch: 41800 acc: 0.9266666666666666
epoch: 42000 acc: 0.9266666666666666
epoch: 42200 acc: 0.9333333333333333
epoch: 42400 acc: 0.9333333333333333
epoch: 42600 acc: 0.9333333333333333
epoch: 42800 acc: 0.9333333333333333
epoch: 43000 acc: 0.9333333333333333
epoch: 43200 acc: 0.9333333333333333
epoch: 43400 acc: 0.9333333333333333
epoch: 43600 acc: 0.9333333333333333
epoch: 43800 acc: 0.9333333333333333
epoch: 44000 acc: 0.9333333333333333
epoch: 44200 acc: 0.9333333333333333
epoch: 44400 acc: 0.9333333333333333
epoch: 44600 acc: 0.9333333333333333
epoch: 44800 acc: 0.94
epoch: 45000 acc: 0.94
epoch: 45200 acc: 0.94
epoch: 45400 acc: 0.94
epoch: 45600 acc: 0.9466666666666667
epoch: 45800 acc: 0.9466666666666667
epoch: 46000 acc: 0.9466666666666667
epoch: 46200 acc: 0.9466666666666667
epoch: 46400 acc: 0.9466666666666667
epoch: 46600 acc: 0.9466666666666667
epoch: 46800 acc: 0.9466666666666667
epoch: 47000 acc: 0.9466666666666667
epoch: 47200 acc: 0.9466666666666667
epoch: 47400 acc: 0.9466666666666667
epoch: 47600 acc: 0.9466666666666667
epoch: 47800 acc: 0.9466666666666667
epoch: 48000 acc: 0.9466666666666667
epoch: 48200 acc: 0.9466666666666667
epoch: 48400 acc: 0.9466666666666667
epoch: 48600 acc: 0.9466666666666667
epoch: 48800 acc: 0.9466666666666667
epoch: 49000 acc: 0.9466666666666667
epoch: 49200 acc: 0.9466666666666667
epoch: 49400 acc: 0.9466666666666667
epoch: 49600 acc: 0.9466666666666667
epoch: 49800 acc: 0.9466666666666667
epoch: 50000 acc: 0.9466666666666667
epoch: 50200 acc: 0.9466666666666667
epoch: 50400 acc: 0.9466666666666667
epoch: 50600 acc: 0.9466666666666667
epoch: 50800 acc: 0.9466666666666667
epoch: 51000 acc: 0.9466666666666667
epoch: 51200 acc: 0.9466666666666667
epoch: 51400 acc: 0.9466666666666667
epoch: 51600 acc: 0.9533333333333334
epoch: 51800 acc: 0.9533333333333334
epoch: 52000 acc: 0.96
epoch: 52200 acc: 0.96
epoch: 52400 acc: 0.96
epoch: 52600 acc: 0.96
epoch: 52800 acc: 0.96
epoch: 53000 acc: 0.96
epoch: 53200 acc: 0.96
epoch: 53400 acc: 0.96
epoch: 53600 acc: 0.96
epoch: 53800 acc: 0.96
epoch: 54000 acc: 0.96
epoch: 54200 acc: 0.96
epoch: 54400 acc: 0.96
epoch: 54600 acc: 0.96
epoch: 54800 acc: 0.96
epoch: 55000 acc: 0.96
epoch: 55200 acc: 0.96
epoch: 55400 acc: 0.96
epoch: 55600 acc: 0.96
epoch: 55800 acc: 0.96
epoch: 56000 acc: 0.96
epoch: 56200 acc: 0.96
epoch: 56400 acc: 0.96
epoch: 56600 acc: 0.96
epoch: 56800 acc: 0.96
epoch: 57000 acc: 0.96
epoch: 57200 acc: 0.96
epoch: 57400 acc: 0.96
epoch: 57600 acc: 0.96
epoch: 57800 acc: 0.96
epoch: 58000 acc: 0.96
epoch: 58200 acc: 0.96
epoch: 58400 acc: 0.96
epoch: 58600 acc: 0.96
epoch: 58800 acc: 0.96
epoch: 59000 acc: 0.96
epoch: 59200 acc: 0.96
epoch: 59400 acc: 0.96
epoch: 59600 acc: 0.96
epoch: 59800 acc: 0.96
epoch: 60000 acc: 0.96

Process finished with exit code 0

文章推荐阅读(另外一种方式的!)：多类支持向量机损失 Multiclass Support Vector Machine Loss+Python代码实战Mnist数据集！
硬间隔手写详细推导
软间隔手写详细推导

三. 随机梯度下降实现

import numpy as np
from time import *

batchsz = 500
np.random.seed(0)

# 0. 定义函数实现mini_batch
def mini_batches(X, Y, mini_batch_size=batchsz, seed=0):
    np.random.seed(seed)
    m = X.shape[0]                                # m是样本数

    mini_batches = []                             # 用来存放一个一个的mini_batch

    num_complete_minibatches = int(m // mini_batch_size)  # 样本总数除以每个batch的样本数量
    for i in range(num_complete_minibatches):
        mini_batch_X = X[i * mini_batch_size:(i + 1) * mini_batch_size, :]
        mini_batch_Y = Y[i * mini_batch_size:(i + 1) * mini_batch_size, :]
        mini_batch = (mini_batch_X, mini_batch_Y)
        mini_batches.append(mini_batch)

    if m % mini_batch_size != 0:
        # 如果样本数不能被整除，取余下的部分
        mini_batch_X = X[num_complete_minibatches * mini_batch_size:, :]
        mini_batch_Y = Y[num_complete_minibatches * mini_batch_size, :]
        mini_batch = (mini_batch_X, mini_batch_Y)
        mini_batches.append(mini_batch)
    return mini_batches


# mini_batches = mini_batches(X_train, y_train, mini_batch_size=64, seed=0)
#
# mini_batches[780][0].shape
# (64, 32, 32, 3)


# 1. 随机梯度下降法实现优化SVM
def obtain_w_via_gradient_descent(x, c, y, penalty_c, x_test, y_test_onehot, threshold = 1e-19, learn_rate = 1e-4):
    """ 利用梯度下降法求解如下的SVM问题：min 1/2 * w^T * w + C * Σ_i=1:n（max(0, 1 - y_i * (w^T * x_i + b))）
    :param x: 训练样本 x = [x_1, x_2, ..., x_i]
    :param c: 类别数
    :param y: 样本标签 y = [y_1, y_2, ..., y_c]
    :param threshold: 梯度下降停止阈值
    """
    data_num = np.shape(x)[1]
    feature_dim = np.shape(x)[0]
    w = np.ones([feature_dim, c], dtype=np.float32)
    b = np.ones([c, 1], dtype=np.float32)
    dl_dw = np.zeros([feature_dim, c], dtype=np.float)
    dl_db = np.zeros([c, 1], dtype=np.float)
    epoch = 1
    th = 0.1

    iterations = mini_batches(x.T, y.T, batchsz, seed=0)  # mini_batchs
    print(iterations[0][0].shape)

    begin_time = time()
    while epoch < 100000 and th > threshold:

        for x_y in iterations:
            x = x_y[0].T
            y = x_y[1].T
            a = np.tile(b, [1, batchsz])
            ksi = (np.transpose(w) @ x + np.tile(b, [1, batchsz])) * y
            index_martix = ksi < 1

            for class_num in range(c):
                index_vector = index_martix[class_num, :]

                if True in index_vector:
                    x_c = x[:, index_vector]

                    data_num_c = np.shape(x_c)[1]
                    e = np.ones([data_num_c, 1], dtype=np.float)
                    y_c = np.reshape(y[class_num, index_vector], [data_num_c, 1])
                    w_c = np.reshape(w[:, class_num], [feature_dim, 1])
                    b_c = b[class_num]

                    dl_dw[:, class_num] = (w_c + 2 * penalty_c * (x_c @ np.transpose(x_c) @ w_c +
                                                                  x_c @ e * b_c -
                                                                  x_c @ y_c))[:, 0]
                    dl_db[class_num, 0] = 2 * penalty_c * (b_c * data_num_c +
                                                           np.transpose(w_c) @ x_c @ e -
                                                           np.transpose(y_c) @ e)
                else:
                    w_c = np.reshape(w[:, class_num], [feature_dim, 1])
                    dl_dw[:, class_num] = w_c[:, 0]
                    dl_db[class_num, 0] = 0

            w_ = w - learn_rate * (dl_dw / np.linalg.norm(dl_dw, ord=2))
            b_ = b - learn_rate * dl_db

            th = np.sum(np.square(w_ - w)) + np.sum(np.square(b_ - b))
            epoch = epoch + 1

            w = w_
            b = b_

            #############################################################################
            if epoch % 100 == 0:                   # 训练过程中准确率打印
                y_predict = np.transpose(w) @ x + np.tile(b, [1, batchsz])
                correct_prediction = np.equal(np.argmax(y_predict, 0), np.argmax(y, 0))
                accuracy = np.mean(correct_prediction.astype(np.float))
                print("epoch:", epoch, "acc:", accuracy)

    end_time = time()
    run_time = end_time - begin_time
    print('Run  time：', run_time)             # 该循环程序运行时间
    ########################################## 测试集结果 ############################
    data_num = np.shape(x_test)[1]

    y_predict = np.transpose(w) @ x_test + np.tile(b, [1, data_num])
    correct_prediction = np.equal(np.argmax(y_predict, 0), np.argmax(y_test_onehot, 0))
    accuracy = np.mean(correct_prediction.astype(np.float))
    print("Test_acc:", accuracy)


# 2. 归一化数据
def normalize_data(data):
    mean = np.mean(data, axis=0)
    std = np.std(data, axis=0)
    for i in range(data.shape[0]):
        data[i, :] = (data[i, :] - mean) / std
    return  data

# 3. 转化为one_hot编码
def convert_to_one_hot(y, C):
    return np.eye(C)[y.reshape(-1)]

# 4. 随机打散训练数据和相应的标签
def random_scattered(data):
    index = np.arange(data.shape[0])
    np.random.shuffle(index)
    data = data[index,:]
    return data


def main():
    # 1. 数据集加载
    data = np.loadtxt('one2.txt', dtype=float, delimiter=',')
    # 2. 随机打散训练数据和相应的标签
    data = random_scattered(data)
    # 3. 拆分训练数据和测试数据;
    train_num = int(0.75 * data.shape[0])
    data_train_label = data[:train_num, :]      # 训练集75%
    data_test_lable = data[train_num + 1:, :]   # 测试集25%

    ################################### 训练集 ###################################
    x = data_train_label[:, :4]
    # 3. 归一化
    x = normalize_data(x)
    y = data_train_label[:, 4]
    y = y.astype(np.int)-1
    # 4. 转换one_hot编码
    y_onehot = convert_to_one_hot(y, 2)
    y_onehot[y_onehot == 0] = -1

    x = np.transpose(x)                         # k*n  k: 特征维度， n: 样本数
    y_onehot = np.transpose(y_onehot)           # c*n  c: 类别数，   n: 样本数
    w = np.array([[1, 1, 1], [1, 1, 1]])        # k*c  k: 特征维度,  c: 类别数
    b = np.array([[1],[1],[1]])                 # c*1  c: 类别数

    ################################### 测试集 ###################################
    x_test = data_test_lable[:, :4]
    # 3. 归一化
    x_test = normalize_data(x_test)
    y_test = data_test_lable[:, 4]
    y_test = y_test.astype(np.int)-1
    # 4. 转换one_hot编码
    y_test_onehot = convert_to_one_hot(y_test, 2)
    y_test_onehot[y_test_onehot == 0] = -1

    x_test = np.transpose(x_test)                         # k*n  k: 特征维度， n: 样本数
    y_test_onehot = np.transpose(y_test_onehot)           # c*n  c: 类别数，   n: 样本数


    obtain_w_via_gradient_descent(x, 2, y_onehot, 0.5, x_test, y_test_onehot)

if __name__ == '__main__':
    main()

one2.txt部分

6.64E+01,3.53E+02,5.35E+03,9.50E+02,1
6.18E+01,2.34E+02,4.77E+03,9.50E+02,1
6.71E+01,2.80E+02,5.44E+03,9.32E+02,1
6.30E+01,2.06E+02,4.89E+03,9.27E+02,1
6.67E+01,1.75E+02,5.37E+03,9.15E+02,1
7.54E+01,8.78E+01,6.60E+03,9.14E+02,1
6.83E+01,2.16E+02,5.58E+03,9.14E+02,1
6.58E+01,1.79E+02,5.24E+03,9.12E+02,1
6.93E+01,2.53E+02,5.71E+03,9.10E+02,1
6.73E+01,2.69E+02,5.44E+03,9.08E+02,1
6.20E+01,7.08E+01,4.75E+03,9.06E+02,1
6.70E+01,1.03E+02,5.39E+03,9.04E+02,1
6.43E+01,1.08E+02,5.04E+03,9.03E+02,1
6.73E+01,2.90E+02,5.43E+03,9.01E+02,1
6.64E+01,2.08E+02,5.31E+03,8.98E+02,1
6.52E+01,9.82E+01,5.15E+03,8.91E+02,1
6.45E+01,2.13E+02,5.05E+03,8.91E+02,1
6.21E+01,1.50E+02,4.75E+03,8.90E+02,1
6.72E+01,2.05E+02,5.40E+03,8.84E+02,1
6.33E+01,2.74E+02,4.89E+03,8.83E+02,1
6.46E+01,1.53E+02,5.05E+03,8.83E+02,1
6.48E+01,1.33E+02,4.94E+03,7.45E+02,2
7.55E+01,1.34E+02,6.44E+03,7.45E+02,2
7.04E+01,3.49E+02,5.70E+03,7.45E+02,2
7.03E+01,1.74E+02,5.69E+03,7.45E+02,2
6.70E+01,1.48E+02,5.23E+03,7.45E+02,2
7.25E+01,1.25E+02,6.00E+03,7.45E+02,2
6.72E+01,2.20E+02,5.26E+03,7.45E+02,2
7.56E+01,9.81E+01,6.46E+03,7.45E+02,2
7.54E+01,2.08E+02,6.43E+03,7.45E+02,2
6.83E+01,1.29E+02,5.41E+03,7.45E+02,2
6.35E+01,1.56E+02,4.78E+03,7.45E+02,2
6.45E+01,2.58E+02,4.90E+03,7.45E+02,2
6.44E+01,2.17E+02,4.89E+03,7.45E+02,2
6.42E+01,1.02E+02,4.87E+03,7.45E+02,2
6.09E+01,1.53E+02,4.45E+03,7.45E+02,2
6.66E+01,2.02E+02,5.18E+03,7.45E+02,2
6.53E+01,1.17E+02,5.01E+03,7.45E+02,2

补充：python中读取文件txt文件的几种方式

new.txt

1000025,5,1,1,1,2,1,3,1,1,2
1002945,5,4,4,5,7,10,3,2,1,2
1151734,10,8,7,4,3,10,7,9,1,4
1156017,3,1,1,1,2,1,2,1,1,2
1158247,1,1,1,1,1,1,1,1,1,2
1238021,1,1,1,1,2,1,2,1,1,2
1238464,1,1,1,1,1,?,2,1,1,2
1238633,10,10,10,6,8,4,8,5,1,4
1295186,10,10,10,1,6,1,2,8,1,4
527337,4,1,1,1,2,1,1,1,1,2
558538,4,1,3,3,2,1,1,1,1,2
1266124,5,1,2,1,2,1,1,1,1,2
1296025,4,1,2,1,2,1,1,1,1,2
1296263,4,1,1,1,2,1,1,1,1,2
1296593,5,2,1,1,2,1,1,1,1,2
1299161,4,8,7,10,4,10,7,5,1,4
1301945,5,1,1,1,1,1,1,1,1,2
1302428,5,3,2,4,2,1,1,1,1,2
1318169,9,10,10,10,10,5,10,10,10,4
1113061,5,1,1,1,2,1,3,1,1,2
1116192,5,1,2,1,2,1,3,1,1,2
1135090,4,1,1,1,2,1,2,1,1,2
1145420,6,1,1,1,2,1,2,1,1,2
1158157,5,1,1,1,2,2,2,1,1,2
1171578,3,1,1,1,2,1,1,1,1,2
1174841,5,3,1,1,2,1,1,1,1,2
1184586,4,1,1,1,2,1,2,1,1,2
1186936,2,1,3,2,2,1,2,1,1,2
1197527,5,1,1,1,2,1,2,1,1,2
1222464,6,10,10,10,4,10,7,10,1,4
1240603,2,1,1,1,1,1,1,1,1,2

import numpy as np
import pandas as pd
def main():
    data = pd.read_csv('new.txt')  # 数据集用逗号分隔，直接用txt,也可以读取CSV格式的。
    data = data.values             # DataFrame类型转换成Numpy中array类型,并把表头去掉;
    data

if __name__ == '__main__':
    main()

创作不易，欢迎点赞转发！

机器学习中如何将数据集拆分为mini_batch?numpy代码实现

你可能感兴趣的:(Machine,Learning学习笔记,Deep,Learning学习笔记,自己的工作)

机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
随笔 | 仙一般的灵气海思沧海
仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
想家爆米花机
也许不同于大家对家乡的思念，我对家乡甚至是疯狂的不舍。还未踏出车站就感觉到幸福，我享受这里的夕阳、这里的浓烈柴火味、这里每一口家常菜。我是宅女，我贪恋家的安逸。刚刚踏出大学校门，初出茅庐，无法适应每年只能国庆和春节回家。我焦虑、失眠、无端发脾气，是无法适应工作的节奏，是无法接受我将一步步离开家乡的事实。我不想承认自己胸无大志，选择再次踏上征程。图片发自App
小丽成长记（四十三）玲玲54321
小丽发现，即使她好不容易调整好自己的心态下一秒总会有不确定的伤脑筋的事出现，一个接一个的问题，人生就没有停下的时候，小问题不断出现。不过她今天看的书，她接受了人生就是不确定的，厉害的人就是不断创造确定性，在Ta的领域比别人多的确定性就能让自己脱颖而出，显示价值从而获得的比别人多的利益。正是这样的原因，因为从前修炼自己太少，使得她现在在人生道路上打怪起来困难重重，她似乎永远摆脱不了那种无力感，有种习
2021年12月19日，春蕾教育集团团建活动感受——黄晓丹黄错错加油
感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
《投行人生》读书笔记小蘑菇的树洞
《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
《策划经理回忆录之二》路基雅虎
话说三年变六年，飘了，飘了……眨眼，2013年5月，老吴回到了他的家乡——油城从新开启他的工作幻想症生涯。很庆幸，这是一家很有追求，同时敢于尝试的，且实力不容低调的新星房企——金源置业(前身泰源置业)更值得庆幸的是第一个盘就是油城十路的标杆之一:金源盛世。2013年5月，到2015年11月，两年的陪伴，迎来了一场大爆发。2000个筹，5万/筹，直接回笼1个亿！！！这……让我开始认真审视这座看似五线
如何在 Fork 的 GitHub 项目中保留自己的修改并同步上游更新？github_fork_update iBaoxing github
如何在Fork的GitHub项目中保留自己的修改并同步上游更新？在GitHub上Fork了一个项目后，你可能会对项目进行一些修改，同时原作者也在不断更新。如果想要在保留自己修改的基础上，同步原作者的最新更新，很多人会不知所措。本文将详细讲解如何在不丢失自己改动的情况下，将上游仓库的更新合并到自己的仓库中。问题描述假设你在GitHub上Fork了一个项目，并基于该项目做了一些修改，随后你发现原作者对
我校举行新老教师师徒结对仪式暨名师专业工作室工作交流活动李蕾1229
为促进我校教师专业发展，发挥骨干教师的引领带头作用，11月6日下午，我校举行新老教师师徒结对仪式暨名师专业工作室工作交流活动。图片发自App会议由教师发展处李蕾主任主持，首先，由范校长宣读新老教师结对名单及双方承担职责。随后，两位新调入教师陈玉萍、莫正杰分别和他们的师傅鲍元美、刘召彬老师签订了师徒结对协议书。图片发自App图片发自App师徒拥抱、握手。有了师傅就有了目标有了方向，相信两位新教师在师
2021-08-26 影幽
在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
抖音乐买买怎么加入赚钱?赚钱方法是什么测评君高省
你会在抖音买东西吗?如果会，那么一定要免费注册一个乐买买，抖音直播间，橱窗，小视频里的小黄车买东西都可以返佣金!省下来都是自己的，分享还可以赚钱乐买买是好省旗下的抖音返佣平台，乐买买分析社交电商的价值，乐买买属于今年难得的副业项目风口机会，2019年错过做好省的搞钱的黄金时期，那么2022年千万别再错过乐买买至于我为何转到高省呢？当然是高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自
我的烦恼余建梅
我的烦恼。女儿问我：“你给学生布置什么作文题目？”“《我的烦恼》。”“他们都这么大了，你觉得他们还有烦恼吗？”“有啊！每个人都会有自己烦恼。”“我不相信，大人是没有烦恼的，如果说一定有的话，你的烦恼和我写作业有关，而且是小烦恼。不像我，天天被你说，有这样的妈妈，烦恼是没完没了。”女儿愤愤不平。每个人都会有自己的烦恼，处在上有老下有小的年纪，烦恼多的数不完。想干好工作带好孩子，想孝顺父母又想经营好自
【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数广龙宇一起学Rust #Rust设计模式 rust 设计模式开发语言
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
放下是一段成长的修行小莳玥
人来到这个世界上，只有两件事：生和死。一件事已经做完了，另一件你还急什么呢?是人，都有七情六欲。是心，都有喜怒哀乐，这些再正常不过了。别总抱怨自己活得累，过得辛苦。永远记住：舒坦是留给死人的。苦，才是生活；累，才是工作；变，才是命运；忍，才是历练；容，才是智慧；静，才是修养；舍，才会得到；做，才会拥有。人生，活得太清楚，才是最大的不明白。有些事，看得很清，却说不清；有些人，了解很深，却猜不透；有些
活给自己看，笑容才灿烂听着了么
白岩松说“有时候，我们活得很累，并非生活过于刻薄，而是我们太容易被外界的氛围所感染，被他人的情绪所左右。”心情是自己的。若只是活在别人的眼里、嘴里，便掌握不了让自己开心的主动权。人活着，不是为了活给别人看的，唯有做最真实的自己，活给自己看，笑容才灿烂。诚然，世事纷繁复杂，人人都有一张嘴，管也管不了。永远有人欣赏你，也永远有人批评你，不可能做到让所有人都满意，开心做自己才是最重要的。人生苦短，有太多
今天我破防了 sin信仰
今天本来是大年初一，新年的第一天，应该是高高兴兴的一天，但是我怎么也高兴不起来。具体原因很简单，原本计划年后去县城找了一份会计的工作，被公公婆婆否定了，我心里立马就不舒服了，但是当时刚好肚子疼，我去了厕所，等我上完厕所，公公由于喝了酒还在那里和婆婆唠叨个没完。然后我就在心情极度压抑的情况下把午饭吃完的碗筷和锅给刷了。边刷碗筷和锅，边在那里难受，感觉自己在这个家里真的是过的憋屈死了，公婆不让我去上班
LLM 词汇表落难Coder LLMs NLP 大语言模型大模型 llama 人工智能
Contextwindow“上下文窗口”是指语言模型在生成新文本时能够回溯和参考的文本量。这不同于语言模型训练时所使用的大量数据集，而是代表了模型的“工作记忆”。较大的上下文窗口可以让模型理解和响应更复杂和更长的提示，而较小的上下文窗口可能会限制模型处理较长提示或在长时间对话中保持连贯性的能力。Fine-tuning微调是使用额外的数据进一步训练预训练语言模型的过程。这使得模型开始表示和模仿微调数
将cmd中命令输出保存为txt文本文件落难Coder Windows cmd window
最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
感赏日志133 马姐读书
图片发自App感赏自己今天买个扫地机，以后可以解放出来多看点书，让这个智能小机器人替我工作了。感赏孩子最近进步很大，每天按时上学，认真听课，认真背书，主动认真完成老师布置的作业。感赏自己明白自己容易受到某人的影响，心情不好，每当此刻我就会舒缓，感赏，让自己尽快抽离，想好的一面。感赏儿子今天在我提醒他事情时，告诉我谢谢妈妈对我的提醒我明白了，而不是说我啰嗦，管事情，孩子更懂事了，懂得感恩了。投射父母
关于提高复杂业务逻辑代码可读性的思考编程经验分享开发经验 java 数据库开发语言
目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
拥有断舍离的心态，过精简生活--《断舍离》读书笔记爱吃丸子的小樱桃
不知不觉间房间里的东西越来越多，虽然摆放整齐，但也时常会觉得空间逼仄，令人心生烦闷。抱着断舍离的态度，我开始阅读《断舍离》这本书，希望从书中能找到一些有效的方法，帮助我实现空间、物品上的断舍离。《断舍离》是日本作家山下英子通过自己的经历、思考和实践总结而成的，整体内涵也从刚开始的私人生活哲学的“断舍离”升华成了“人生实践哲学”，接着又成为每个人都能实行的“改变人生的断舍离”，从“哲学”逐渐升华成“
四章-32-点要素的聚合彩云飘过
本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
《人世间》南询yi
今日分享十点推文，《人世间》有感苏格拉底说：“天地只有三尺，而人在五尺开外，所以人人都要懂得低头。”深以为然。懂得低头，不是认输。而是于人世间找寻温存的成熟，于困境中寻觅柳暗花明的智慧，于争执中展示屈伸自如的格局。正如仰头不是骄傲，是要看见自己的天空；低头也不是认输，而是要看清自己的路。成大事者，不仅要抬头挺胸，还得低头看路。懂得低头，进退有度，不是认输，而是竭尽全力过好这一生。宫崎骏说过：“所有
2.0践行没有你的参与就不完美 x秀丽x
亲爱的伙伴们早上好，今天早上我们开了一次班委竞选的会议，全程只有20多个人参与，宫班本着对大家负责任的态度告诉我们，此次竞选作废，原因是这没有达到2.0的100%参会要求，如果没有大家的参与那么这个班委选出来还有什么意义，这说明选出来的人也是不一定是我们大家心目中认可的那个人，所以为了让大家的这个90天能够更好的激发出自己的的“做”的能力，那么要从第一次竞选班委的会议开始做到100%出席会议，竞选
GitHub上克隆项目 bigbig猩猩 github
从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
把握“三度”打造“三有”干部队伍辛德瑞拉卡卡卡
“胜败兴亡之分，不得不归咎于人事也”。干部队伍建设工作的好坏，关系到党和国家的发展全局。近日，新疆维吾尔自治区党委书记马兴瑞在部分党群单位走访调研时强调，要努力培养造就忠诚干净担当的高素质专业化干部队伍。各级组织部门应当在培养选拔干部、吸收优秀青年到党内来、培养造就优秀人才上下功夫，切实增强干部投身实践、解决问题、推进工作的能力，着力打造高素质专业化干部队伍。“天生我材必有用”，增强选育有“准度”
Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Python python 开发语言大数据数据分析数据挖掘
大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
读书||陶新华《教育中的积极心理学》1—28 流水淙淙2022
读一本好书，尤如和一位高尚者对话，亦能对人的精神进行洗礼。但是若不能和实践结合起来，也只能落到空读书的状态。读书摘要与感想1、塞利格曼在《持续的幸福》一书中提出了幸福2.0理论，提出幸福由5个元素决定——积极情绪、投入的工作和生活、目标和意义、和谐的人际关系、成就感。2、人的大脑皮层在进行智力活动时，都伴有皮下中枢活动，对这些活动进行体验请假，并由此产生了情感解读。人的情绪情感体验总是优先于大脑的
人工智能时代，程序员如何保持核心竞争力？ jmoych 人工智能
随着AIGC（如chatgpt、midjourney、claude等）大语言模型接二连三的涌现，AI辅助编程工具日益普及，程序员的工作方式正在发生深刻变革。有人担心AI可能取代部分编程工作，也有人认为AI是提高效率的得力助手。面对这一趋势,程序员应该如何应对?是专注于某个领域深耕细作，还是广泛学习以适应快速变化的技术环境?又或者，我们是否应该将重点转向AI无法轻易替代的软技能？让我们一起探讨程序员
人生的每一步路都算数 sheli
如果你想打工，一直靠打工赚钱，那你就会不断的希望自己变得更专业，不断的希望能够获得更好的工作机会，升职加薪。如果你的目标志不在此，而是拥有自己的企业，那你的选择就会出现差别。在认真打工的人眼里，会“不务正业”，会总是选择不同岗位，甚至放弃高薪机会。但是这背后都是有更加长远的规划。成功富人所必需的管理技能包括：1．对现金流的管理。2．对系统的管理。3．对人员的管理。所以，在没有获得这些能力之前，只要
项目中枚举与注解的结合使用飞翔的马甲 java enum annotation
前言：版本兼容，一直是迭代开发头疼的事，最近新版本加上了支持新题型，如果新创建一份问卷包含了新题型，那旧版本客户端就不支持，如果新创建的问卷不包含新题型，那么新旧客户端都支持。这里面我们通过给问卷类型枚举增加自定义注解的方式完成。顺便巩固下枚举与注解。一、枚举 1.在创建枚举类的时候，该类已继承java.lang.Enum类，所以自定义枚举类无法继承别的类，但可以实现接口。
【Scala十七】Scala核心十一：下划线_的用法 bit1129 scala
下划线_在Scala中广泛应用，_的基本含义是作为占位符使用。_在使用时是出问题非常多的地方，本文将不断完善_的使用场景以及所表达的含义 1. 在高阶函数中使用 scala> val list = List(-3,8,7,9) list: List[Int] = List(-3, 8, 7, 9) scala> list.filter(_ > 7) r
web缓存基础：术语、http报头和缓存策略 dalan_123 Web
对于很多人来说，去访问某一个站点，若是该站点能够提供智能化的内容缓存来提高用户体验，那么最终该站点的访问者将络绎不绝。缓存或者对之前的请求临时存储，是http协议实现中最核心的内容分发策略之一。分发路径中的组件均可以缓存内容来加速后续的请求，这是受控于对该内容所声明的缓存策略。接下来将讨web内容缓存策略的基本概念，具体包括如如何选择缓存策略以保证互联网范围内的缓存能够正确处理的您的内容，并谈论下
crontab 问题周凡杨 linux crontab unix
一： 0481-079 Reached a symbol that is not expected. 背景： */5 * * * * /usr/IBMIHS/rsync.sh
让tomcat支持2级域名共享session g21121 session
tomcat默认情况下是不支持2级域名共享session的，所有有些情况下登陆后从主域名跳转到子域名会发生链接session不相同的情况，但是只需修改几处配置就可以了。打开tomcat下conf下context.xml文件找到Context标签,修改为如下内容如果你的域名是www.test.com <Context sessionCookiePath="/path&q
web报表工具FineReport常用函数的用法总结（数学和三角函数）老A不折腾 Web finereport 总结
ABS ABS(number):返回指定数字的绝对值。绝对值是指没有正负符号的数值。 Number:需要求出绝对值的任意实数。示例: ABS(-1.5)等于1.5。 ABS(0)等于0。 ABS(2.5)等于2.5。 ACOS ACOS(number):返回指定数值的反余弦值。反余弦值为一个角度，返回角度以弧度形式表示。 Number:需要返回角
linux 启动java进程 sh文件墙头上一根草 linux shell jar
#!/bin/bash #初始化服务器的进程PId变量 user_pid=0; robot_pid=0; loadlort_pid=0; gateway_pid=0; ######### #检查相关服务器是否启动成功 #说明： #使用JDK自带的JPS命令及grep命令组合，准确查找pid #jps 加 l 参数，表示显示java的完整包路径 #使用awk，分割出pid
我的spring学习笔记5-如何使用ApplicationContext替换BeanFactory aijuans Spring 3 系列
如何使用ApplicationContext替换BeanFactory？ package onlyfun.caterpillar.device; import org.springframework.beans.factory.BeanFactory; import org.springframework.beans.factory.xml.XmlBeanFactory; import
Linux 内存使用方法详细解析 annan211 linux 内存 Linux内存解析
来源 http://blog.jobbole.com/45748/ 我是一名程序员，那么我在这里以一个程序员的角度来讲解Linux内存的使用。一提到内存管理，我们头脑中闪出的两个概念，就是虚拟内存，与物理内存。这两个概念主要来自于linux内核的支持。 Linux在内存管理上份为两级，一级是线性区，类似于00c73000-00c88000，对应于虚拟内存，它实际上不占用
数据库的单表查询常用命令及使用方法(-) 百合不是茶 oracle 函数单表查询
创建数据库; --建表 create table bloguser(username varchar2(20),userage number(10),usersex char(2)); 创建bloguser表,里面有三个字段 &nbs
多线程基础知识 bijian1013 java 多线程 thread java多线程
一．进程和线程进程就是一个在内存中独立运行的程序，有自己的地址空间。如正在运行的写字板程序就是一个进程。 “多任务”：指操作系统能同时运行多个进程（程序）。如WINDOWS系统可以同时运行写字板程序、画图程序、WORD、Eclipse等。线程：是进程内部单一的一个顺序控制流。线程和进程 a. 每个进程都有独立的
fastjson简单使用实例 bijian1013 fastjson
一.简介阿里巴巴fastjson是一个Java语言编写的高性能功能完善的JSON库。它采用一种“假定有序快速匹配”的算法，把JSON Parse的性能提升到极致，是目前Java语言中最快的JSON库；包括“序列化”和“反序列化”两部分，它具备如下特征：
【RPC框架Burlap】Spring集成Burlap bit1129 spring
Burlap和Hessian同属于codehaus的RPC调用框架，但是Burlap已经几年不更新，所以Spring在4.0里已经将Burlap的支持置为Deprecated,所以在选择RPC框架时，不应该考虑Burlap了。这篇文章还是记录下Burlap的用法吧，主要是复制粘贴了Hessian与Spring集成一文，【RPC框架Hessian四】Hessian与Spring集成
【Mahout一】基于Mahout 命令参数含义 bit1129 Mahout
1. mahout seqdirectory $ mahout seqdirectory --input (-i) input Path to job input directory(原始文本文件). --output (-o) output The directory pathna
linux使用flock文件锁解决脚本重复执行问题 ronin47 linux lock　重复执行
linux的crontab命令，可以定时执行操作，最小周期是每分钟执行一次。关于crontab实现每秒执行可参考我之前的文章《linux crontab 实现每秒执行》现在有个问题，如果设定了任务每分钟执行一次，但有可能一分钟内任务并没有执行完成，这时系统会再执行任务。导致两个相同的任务在执行。例如： <? // test .php
java-74-数组中有一个数字出现的次数超过了数组长度的一半，找出这个数字 bylijinnan java
public class OcuppyMoreThanHalf { /** * Q74 数组中有一个数字出现的次数超过了数组长度的一半，找出这个数字 * two solutions: * 1.O(n) * see <beauty of coding>--每次删除两个不同的数字，不改变数组的特性 * 2.O(nlogn) * 排序。中间
linux 系统相关命令 candiio linux
系统参数 cat /proc/cpuinfo cpu相关参数 cat /proc/meminfo 内存相关参数 cat /proc/loadavg 负载情况性能参数 1）top M：按内存使用排序 P：按CPU占用排序 1：显示各CPU的使用情况 k：kill进程 o：更多排序规则回车：刷新数据 2）ulimit ulimit -a：显示本用户的系统限制参
[经营与资产]保持独立性和稳定性对于软件开发的重要意义 comsci 软件开发
一个软件的架构从诞生到成熟，中间要经过很多次的修正和改造如果在这个过程中，外界的其它行业的资本不断的介入这种软件架构的升级过程中那么软件开发者原有的设计思想和开发路线
在CentOS5.5上编译OpenJDK6 Cwind linux OpenJDK
几番周折终于在自己的CentOS5.5上编译成功了OpenJDK6，将编译过程和遇到的问题作一简要记录，备查。 0. OpenJDK介绍 OpenJDK是Sun（现Oracle）公司发布的基于GPL许可的Java平台的实现。其优点： 1、它的核心代码与同时期Sun（-> Oracle）的产品版基本上是一样的，血统纯正，不用担心性能问题，也基本上没什么兼容性问题；（代码上最主要的差异是
java乱码问题 dashuaifu java乱码问题 js中文乱码
swfupload上传文件参数值为中文传递到后台接收中文乱码在js中用setPostParams（{"tag" : encodeURI( document.getElementByIdx_x("filetag").value，"utf-8")}）; 然后在servlet中String t
cygwin很多命令显示command not found的解决办法 dcj3sjt126com cygwin
cygwin很多命令显示command not found的解决办法修改cygwin.BAT文件如下 @echo off D: set CYGWIN=tty notitle glob set PATH=%PATH%;d:\cygwin\bin;d:\cygwin\sbin;d:\cygwin\usr\bin;d:\cygwin\usr\sbin;d:\cygwin\us
[介绍]从 Yii 1.1 升级 dcj3sjt126com PHP yii2
2.0 版框架是完全重写的，在 1.1 和 2.0 两个版本之间存在相当多差异。因此从 1.1 版升级并不像小版本间的跨越那么简单，通过本指南你将会了解两个版本间主要的不同之处。如果你之前没有用过 Yii 1.1，可以跳过本章，直接从"入门篇"开始读起。请注意，Yii 2.0 引入了很多本章并没有涉及到的新功能。强烈建议你通读整部权威指南来了解所有新特性。这样有可能会发
Linux SSH免登录配置总结 eksliang ssh-keygen Linux SSH免登录认证 Linux SSH互信
转载请出自出处：http://eksliang.iteye.com/blog/2187265 一、原理我们使用ssh-keygen在ServerA上生成私钥跟公钥，将生成的公钥拷贝到远程机器ServerB上后,就可以使用ssh命令无需密码登录到另外一台机器ServerB上。生成公钥与私钥有两种加密方式，第一种是
手势滑动销毁Activity gundumw100 android
老是效仿ios，做android的真悲催！有需求：需要手势滑动销毁一个Activity 怎么办尼？自己写？不用~，网上先问一下百度。结果： http://blog.csdn.net/xiaanming/article/details/20934541 首先将你需要的Activity继承SwipeBackActivity，它会在你的布局根目录新增一层SwipeBackLay
JavaScript变换表格边框颜色 ini JavaScript html Web html5 css
效果查看：http://hovertree.com/texiao/js/2.htm代码如下，保存到HTML文件也可以查看效果： <html> <head> <meta charset="utf-8"> <title>表格边框变换颜色代码-何问起</title> </head> <body&
Kafka Rest : Confluent kane_xie kafka REST confluent
最近拿到一个kafka rest的需求，但kafka暂时还没有提供rest api（应该是有在开发中，毕竟rest这么火），上网搜了一下，找到一个Confluent Platform，本文简单介绍一下安装。这里插一句，给大家推荐一个九尾搜索，原名叫谷粉SOSO，不想fanqiang谷歌的可以用这个。以前在外企用谷歌用习惯了，出来之后用度娘搜技术问题，那匹配度简直感人。环境声明：Ubu
Calender不是单例 men4661273 单例 Calender
在我们使用Calender的时候，使用过Calendar.getInstance()来获取一个日期类的对象，这种方式跟单例的获取方式一样，那么它到底是不是单例呢，如果是单例的话，一个对象修改内容之后，另外一个线程中的数据不久乱套了吗？从试验以及源码中可以得出，Calendar不是单例。测试： Calendar c1 =
线程内存和主内存之间联系 qifeifei java thread
1， java多线程共享主内存中变量的时候，一共会经过几个阶段， lock:将主内存中的变量锁定，为一个线程所独占。 unclock:将lock加的锁定解除，此时其它的线程可以有机会访问此变量。 read:将主内存中的变量值读到工作内存当中。 load:将read读取的值保存到工作内存中的变量副本中。
schedule和scheduleAtFixedRate tangqi609567707 java timer schedule
原文地址：http://blog.csdn.net/weidan1121/article/details/527307 import java.util.Timer;import java.util.TimerTask;import java.util.Date; /** * @author vincent */public class TimerTest {
erlang 部署 wudixiaotie erlang
1.如果在启动节点的时候报这个错： {"init terminating in do_boot",{'cannot load',elf_format,get_files}} 则需要在reltool.config中加入 {app, hipe, [{incl_cond, exclude}]}, 2.当generate时，遇到： ERROR