支持向量机svm代码实现_SVM机器学习教程–什么是支持向量机算法，并通过代码示例进行了解释

支持向量机svm代码实现

Most of the tasks machine learning handles right now include things like classifying images, translating languages, handling large amounts of data from sensors, and predicting future values based on current values. You can choose different strategies to fit the problem you're trying to solve.

机器学习现在处理的大多数任务包括诸如对图像进行分类，翻译语言，处理来自传感器的大量数据以及根据当前值预测未来值之类的任务。 您可以选择不同的策略来解决您要解决的问题。

The good news? There's an algorithm in machine learning that'll handle just about any data you can throw at it. But we'll get there in a minute.

好消息？ 机器学习中有一种算法，可以处理几乎所有您可以向其抛出的数据。 但是，我们一分钟内就会到达那里。

有监督与无监督学习 (Supervised vs Unsupervised learning)

Two of the most commonly used strategies in machine learning include supervised learning and unsupervised learning.

机器学习中最常用的两种策略是监督学习和无监督学习。

什么是监督学习？ (What is supervised learning?)

Supervised learning is when you train a machine learning model using labelled data. It means that you have data that already have the right classification associated with them. One common use of supervised learning is to help you predict values for new data.

监督学习是指您使用标签数据训练机器学习模型时的情况。 这意味着您已经拥有与之关联的正确分类的数据。 监督学习的一种常见用法是帮助您预测新数据的值。

With supervised learning, you'll need to rebuild your models as you get new data to make sure that the predictions returned are still accurate. An example of supervised learning would be labeling pictures of food. You could have a dataset dedicated to just images of pizza to teach your model what pizza is.

通过监督学习，您需要在获取新数据时重建模型，以确保返回的预测仍然准确。 监督学习的一个例子是贴上食物的图片标签。 您可以拥有一个仅用于比萨饼图像的数据集，以教您的模型比萨饼是什么。

什么是无监督学习？ (What is unsupervised learning?)

Unsupervised learning is when you train a model with unlabeled data. This means that the model will have to find its own features and make predictions based on how it classifies the data.

无监督学习是指您使用无标签数据训练模型时的情况。 这意味着该模型将必须找到自己的特征并根据其如何对数据进行分类进行预测。

An example of unsupervised learning would be giving your model pictures of multiple kinds of food with no labels. The dataset would have images of pizza, fries, and other foods and you could use different algorithms to get the model to identify just the images of pizza without any labels.

无监督学习的一个示例是为您的模型照片提供多种食品而没有标签。 该数据集将包含比萨饼，薯条和其他食物的图像，您可以使用不同的算法来获取模型，以仅识别比萨饼图像而没有任何标签。

那么什么是算法？ (So what's an algorithm?)

When you hear people talk about machine learning algorithms, remember that they are talking about different math equations.

当您听到人们谈论机器学习算法时，请记住他们在谈论不同的数学方程式。

An algorithm is just a customizable math function. That's why most algorithms have things like cost functions, weight values, and parameter functions that you can interchange based on the data you're working with. At its core, machine learning is just a bunch of math equations that need to be solved really fast.

算法只是可自定义的数学函数。 这就是为什么大多数算法都具有诸如成本函数，权重值和参数函数之类的东西，您可以根据正在使用的数据进行互换的原因。 机器学习的核心只是一堆需要真正快速求解的数学方程式。

That's why there are so many different algorithms to handle different kinds of data. One particular algorithm is the support vector machine (SVM) and that's what this article is going to cover in detail.

这就是为什么有这么多不同的算法来处理不同种类的数据的原因。 支持向量机(SVM)是一种特殊的算法，本文将对此进行详细介绍。

什么是SVM？ (What is an SVM?)

Support vector machines are a set of supervised learning methods used for classification, regression, and outliers detection. All of these are common tasks in machine learning.

支持向量机是用于分类，回归和离群值检测的一组监督学习方法。 所有这些都是机器学习中的常见任务。

You can use them to detect cancerous cells based on millions of images or you can use them to predict future driving routes with a well-fitted regression model.

您可以使用它们基于数百万张图像检测癌细胞，也可以使用它们通过完善的回归模型预测未来的行驶路线。

There are specific types of SVMs you can use for particular machine learning problems, like support vector regression (SVR) which is an extension of support vector classification (SVC).

您可以针对特定的机器学习问题使用特定类型的SVM，例如支持向量回归(SVR)，它是支持向量分类(SVC)的扩展。

The main thing to keep in mind here is that these are just math equations tuned to give you the most accurate answer possible as quickly as possible.

这里要记住的主要事情是，这些只是数学方程式，已调整为可以尽快为您提供最准确的答案。

SVMs are different from other classification algorithms because of the way they choose the decision boundary that maximizes the distance from the nearest data points of all the classes. The decision boundary created by SVMs is called the maximum margin classifier or the maximum margin hyper plane.

SVM与其他分类算法的不同之处在于，它们选择决策边界的方式可以最大化与所有类别的最近数据点之间的距离。 SVM创建的决策边界称为最大余量分类器或最大余量超平面。

SVM的工作方式 (How an SVM works)

A simple linear SVM classifier works by making a straight line between two classes. That means all of the data points on one side of the line will represent a category and the data points on the other side of the line will be put into a different category. This means there can be an infinite number of lines to choose from.

一个简单的线性SVM分类器通过在两个类之间建立一条直线来工作。 这意味着该行一侧的所有数据点将代表一个类别，而该行另一侧的所有数据点将被置于不同的类别。 这意味着可以有无数行可供选择。

What makes the linear SVM algorithm better than some of the other algorithms, like k-nearest neighbors, is that it chooses the best line to classify your data points. It chooses the line that separates the data and is the furthest away from the closet data points as possible.

使线性SVM算法比其他一些算法(例如k近邻算法)更好的原因是，它选择了最好的线来对数据点进行分类。 它选择分隔数据的行，并且该行离壁橱数据点最远。

A 2-D example helps to make sense of all the machine learning jargon. Basically you have some data points on a grid. You're trying to separate these data points by the category they should fit in, but you don't want to have any data in the wrong category. That means you're trying to find the line between the two closest points that keeps the other data points separated.

一个二维示例有助于理解所有机器学习术语。 基本上，您在网格上有一些数据点。 您试图按它们应适合的类别来分离这些数据点，但是您不想在错误的类别中包含任何数据。 这意味着您试图找到两个最靠近的点之间的线，以使其他数据点保持分离。

So the two closest data points give you the support vectors you'll use to find that line. That line is called the decision boundary.

因此，两个最接近的数据点为您提供了用于查找该线的支持向量。 该线称为决策边界。

The decision boundary doesn't have to be a line. It's also referred to as a hyperplane because you can find the decision boundary with any number of features, not just two.

决策边界不必是一条线。 它也被称为超平面，因为您可以找到具有任意多个特征的决策边界，而不仅仅是两个。

SVM的类型 (Types of SVMs)

There are two different types of SVMs, each used for different things:

有两种不同类型的SVM，分别用于不同的用途：

• Simple SVM: Typically used for linear regression and classification problems.
  简单SVM：通常用于线性回归和分类问题。
• Kernel SVM: Has more flexibility for non-linear data because you can add more features to fit a hyperplane instead of a two-dimensional space.
  内核SVM：对于非线性数据，它具有更大的灵活性，因为您可以添加更多功能以适合超平面而不是二维空间。

为什么在机器学习中使用SVM (Why SVMs are used in machine learning)

SVMs are used in applications like handwriting recognition, intrusion detection, face detection, email classification, gene classification, and in web pages. This is one of the reasons we use SVMs in machine learning. It can handle both classification and regression on linear and non-linear data.

SVM用于诸如手写识别，入侵检测，面部检测，电子邮件分类，基因分类之类的应用程序，以及Web页面中。 这是我们在机器学习中使用SVM的原因之一。 它可以处理线性和非线性数据的分类和回归。

Another reason we use SVMs is because they can find complex relationships between your data without you needing to do a lot of transformations on your own. It's a great option when you are working with smaller datasets that have tens to hundreds of thousands of features. They typically find more accurate results when compared to other algorithms because of their ability to handle small, complex datasets.

我们使用SVM的另一个原因是因为它们可以在您的数据之间找到复杂的关系，而无需您自己进行大量转换。 当您使用具有数以万计的特征的较小数据集时，这是一个不错的选择。 与其他算法相比，它们通常可以找到更准确的结果，因为它们具有处理小型复杂数据集的能力。

Here are some of the pros and cons for using SVMs.

以下是使用SVM的一些优缺点。

优点 (Pros)

• Effective on datasets with multiple features, like financial or medical data.
  对具有多种功能的数据集有效，例如财务或医疗数据。
• Effective in cases where number of features is greater than the number of data points.
  在要素数量大于数据点数量的情况下有效。
• Uses a subset of training points in the decision function called support vectors which makes it memory efficient.
  在决策函数中使用称为支持向量的训练点子集，以提高存储效率。
• Different kernel functions can be specified for the decision function. You can use common kernels, but it's also possible to specify custom kernels.
  可以为决策函数指定不同的内核函数。 您可以使用通用内核，但也可以指定自定义内核。

缺点 (Cons)

• If the number of features is a lot bigger than the number of data points, avoiding over-fitting when choosing kernel functions and regularization term is crucial.
  如果特征的数量比数据点的数量大得多，那么在选择内核函数和正则化项时避免过度拟合至关重要。
• SVMs don't directly provide probability estimates. Those are calculated using an expensive five-fold cross-validation.
  SVM不直接提供概率估计。 这些是使用昂贵的五折交叉验证来计算的。
• Works best on small sample sets because of its high training time.
  由于训练时间长，因此在小样本集上效果最佳。

Since SVMs can use any number of kernels, it's important that you know about a few of them.

由于SVM可以使用任意数量的内核，因此了解其中的几个内核很重要。

内核功能 (Kernel functions)

线性的 (Linear)

These are commonly recommended for text classification because most of these types of classification problems are linearly separable.

通常建议将它们用于文本分类，因为大多数这些类型的分类问题都是线性可分离的。

The linear kernel works really well when there are a lot of features, and text classification problems have a lot of features. Linear kernel functions are faster than most of the others and you have fewer parameters to optimize.

当有很多功能时，线性核确实可以很好地工作，而文本分类问题也有很多功能。 线性核函数比大多数其他函数快，并且您需要优化的参数也更少。

Here's the function that defines the linear kernel:

这是定义线性核的函数：

f(X) = w^T * X + b

In this equation, w is the weight vector that you want to minimize, X is the data that you're trying to classify, and b is the linear coefficient estimated from the training data. This equation defines the decision boundary that the SVM returns.

在此等式中， w是您要最小化的权重向量， X是您要分类的数据， b是根据训练数据估算的线性系数。 该方程式定义了SVM返回的决策边界。

多项式 (Polynomial)

The polynomial kernel isn't used in practice very often because it isn't as computationally efficient as other kernels and its predictions aren't as accurate.

多项式内核在实践中并不经常使用，因为它的计算效率不如其他内核，并且其预测也没有那么精确。

Here's the function for a polynomial kernel:

这是多项式内核的函数：

f(X1, X2) = (a + X1^T * X2) ^ b

This is one of the more simple polynomial kernel equations you can use. f(X1, X2) represents the polynomial decision boundary that will separate your data. X1 and X2 represent your data.

这是您可以使用的更简单的多项式内核方程式之一。 f(X1，X2)表示将分隔数据的多项式决策边界。 X1和X2代表您的数据。

高斯径向基函数(RBF) (Gaussian Radial Basis Function (RBF))

One of the most powerful and commonly used kernels in SVMs. Usually the choice for non-linear data.

SVM中功能最强大且最常用的内核之一。 通常选择非线性数据。

Here's the equation for an RBF kernel:

这是RBF内核的等式：

f(X1, X2) = exp(-gamma * ||X1 - X2||^2)

In this equation, gamma specifies how much a single training point has on the other data points around it. ||X1 - X2|| is the dot product between your features.

在此等式中， 伽玛指定单个训练点在其周围的其他数据点上具有多少。 || X1-X2 || 是您的功能之间的点积。

乙状结肠 (Sigmoid)

More useful in neural networks than in support vector machines, but there are occasional specific use cases.

在神经网络中比在支持向量机中更有用，但是偶尔会有特定的用例。

Here's the function for a sigmoid kernel:

这是S形内核的函数：

f(X, y) = tanh(alpha * X^T * y + C)

In this function, alpha is a weight vector and C is an offset value to account for some mis-classification of data that can happen.

在此函数中， alpha是权重向量， C是偏移值，以说明可能发生的某些数据错误分类。

其他 (Others)

There are plenty of other kernels you can use for your project. This might be a decision to make when you need to meet certain error constraints, you want to try and speed up the training time, or you want to super tune parameters.

您可以在项目中使用许多其他内核。 当您需要满足某些错误限制，想要尝试并加快训练时间或想要超调参数时，这可能是一个决定。

Some other kernels include: ANOVA radial basis, hyperbolic tangent, and Laplace RBF.

其他一些内核包括 ：ANOVA径向基，双曲正切和Laplace RBF。

Now that you know a bit about how the kernels work under the hood, let's go through a couple of examples.

既然您已经了解了内核的工作原理，那么让我们来看几个示例。

数据集示例 (Examples with datasets)

To show you how SVMs work in practice, we'll go through the process of training a model with it using the Python Scikit-learn library. This is commonly used on all kinds of machine learning problems and works well with other Python libraries.

为了向您展示SVM在实践中的工作方式，我们将使用Python Scikit-learn库完成使用模型训练模型的过程。 这通常用于各种机器学习问题，并且可以与其他Python库一起很好地工作。

Here are the steps regularly found in machine learning projects:

以下是机器学习项目中经常发现的步骤：

• Import the dataset
  导入数据集
• Explore the data to figure out what they look like
  探索数据以找出它们的外观
• Pre-process the data
  预处理数据
• Split the data into attributes and labels
  将数据分为属性和标签
• Divide the data into training and testing sets
  将数据分为训练和测试集
• Train the SVM algorithm
  训练SVM算法
• Make some predictions
  做一些预测
• Evaluate the results of the algorithm
  评估算法结果

Some of these steps can be combined depending on how you handle your data. We'll do an example with a linear SVM and a non-linear SVM. You can find the code for these examples here.

这些步骤中的某些步骤可以合并，具体取决于您处理数据的方式。 我们将以线性SVM和非线性SVM为例。 您可以在此处找到这些示例的代码 。

线性SVM示例 (Linear SVM Example)

We'll start by importing a few libraries that will make it easy to work with most machine learning projects.

我们将从导入一些库开始，这些库将使大多数机器学习项目的工作变得容易。

import matplotlib.pyplot as plt
import numpy as np
from sklearn import svm

For a simple linear example, we'll just make some dummy data and that will act in the place of importing a dataset.

对于一个简单的线性示例，我们将制作一些虚拟数据，这些数据将代替导入数据集。

# linear data
X = np.array([1, 5, 1.5, 8, 1, 9, 7, 8.7, 2.3, 5.5, 7.7, 6.1])
y = np.array([2, 8, 1.8, 8, 0.6, 11, 10, 9.4, 4, 3, 8.8, 7.5])

The reason we're working with numpy arrays is to make the matrix operations faster because they use less memory than Python lists. You could also take advantage of typing the contents of the arrays. Now let's take a look at what the data look like in a plot:

我们使用numpy数组的原因是为了使矩阵运算更快，因为它们使用的内存比Python列表少。 您还可以利用键入数组内容的优势。 现在，让我们看一下图中数据的样子：

# show unclassified data
plt.scatter(X, y)
plt.show()

Once you see what the data look like, you can take a better guess at which algorithm will work best for you. Keep in mind that this is a really simple dataset, so most of the time you'll need to do some work on your data to get it to a usable state.

一旦查看了数据的样子，就可以更好地猜测哪种算法最适合您。 请记住，这是一个非常简单的数据集，因此大多数时候您需要对数据进行一些处理才能使其变为可用状态。

We'll do a bit of pre-processing on the already structured code. This will put the raw data into a format that we can use to train the SVM model.

我们将对已经结构化的代码进行一些预处理。 这会将原始数据转换成可用于训练SVM模型的格式。

# shaping data for training the model
training_X = np.vstack((X, y)).T
training_y = [0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1]

Now we can create the SVM model using a linear kernel.

现在，我们可以使用线性内核创建SVM模型。

# define the model
clf = svm.SVC(kernel='linear', C=1.0)

That one line of code just created an entire machine learning model. Now we just have to train it with the data we pre-processed.

一行代码仅创建了一个完整的机器学习模型。 现在，我们只需要使用预处理的数据对其进行训练。

# train the model
clf.fit(training_X, training_y)

That's how you can build a model for any machine learning project. The dataset we have might be small, but if you encounter a real-world dataset that can be classified with a linear boundary this model still works.

这样便可以为任何机器学习项目构建模型。 我们拥有的数据集可能很小，但是如果您遇到可以用线性边界分类的真实数据集，则该模型仍然有效。

With your model trained, you can make predictions on how a new data point will be classified and you can make a plot of the decision boundary. Let's plot the decision boundary.

通过训练模型，您可以预测如何对新数据点进行分类，还可以绘制决策边界图。 让我们绘制决策边界。

# get the weight values for the linear equation from the trained SVM model
w = clf.coef_[0]

# get the y-offset for the linear equation
a = -w[0] / w[1]

# make the x-axis space for the data points
XX = np.linspace(0, 13)

# get the y-values to plot the decision boundary
yy = a * XX - clf.intercept_[0] / w[1]

# plot the decision boundary
plt.plot(XX, yy, 'k-')

# show the plot visually
plt.scatter(training_X[:, 0], training_X[:, 1], c=training_y)
plt.legend()
plt.show()

非线性SVM示例 (Non-Linear SVM Example)

For this example, we'll use a slightly more complicated dataset to show one of the areas SVMs shine in. Let's import some packages.

在此示例中，我们将使用稍微复杂一些的数据集来显示SVM的亮点之一。让我们导入一些软件包。

import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets
from sklearn import svm

This set of imports is similar to those in the linear example, except it imports one more thing. Now we can use a dataset directly from the Scikit-learn library.

此导入集与线性示例中的导入集相似，不同之处在于它又导入了一件事。 现在，我们可以直接从Scikit-learn库使用数据集。

# non-linear data
circle_X, circle_y = datasets.make_circles(n_samples=300, noise=0.05)

The next step is to take a look at what this raw data looks like with a plot.

下一步是使用绘图来查看原始数据的外观。

# show raw non-linear data
plt.scatter(circle_X[:, 0], circle_X[:, 1], c=circle_y, marker='.')
plt.show()

Now that you can see how the data are separated, we can choose a non-linear SVM to start with. This dataset doesn't need any pre-processing before we use it to train the model, so we can skip that step. Here's how the SVM model will look for this:

现在您可以看到如何分离数据，我们可以选择一个非线性SVM作为开始。 在使用该数据集训练模型之前，不需要任何预处理，因此我们可以跳过该步骤。 以下是SVM模型的外观：

# make non-linear algorithm for model
nonlinear_clf = svm.SVC(kernel='rbf', C=1.0)

In this case, we'll go with an RBF (Gaussian Radial Basis Function) kernel to classify this data. You could also try the polynomial kernel to see the difference between the results you get. Now it's time to train the model.

在这种情况下，我们将使用RBF(高斯径向基函数)内核对该数据进行分类。 您也可以尝试多项式内核，以查看所得结果之间的差异。 现在是时候训练模型了。

# training non-linear model
nonlinear_clf.fit(circle_X, circle_y)

You can start labeling new data in the correct category based on this model. To see what the decision boundary looks like, we'll have to make a custom function to plot it.

您可以根据此模型开始在正确的类别中标记新数据。 要查看决策边界是什么样子，我们必须创建一个自定义函数来绘制决策边界。

# Plot the decision boundary for a non-linear SVM problem
def plot_decision_boundary(model, ax=None):
    if ax is None:
        ax = plt.gca()
        
    xlim = ax.get_xlim()
    ylim = ax.get_ylim()
    
    # create grid to evaluate model
    x = np.linspace(xlim[0], xlim[1], 30)
    y = np.linspace(ylim[0], ylim[1], 30)
    Y, X = np.meshgrid(y, x)

	# shape data
    xy = np.vstack([X.ravel(), Y.ravel()]).T
    
	# get the decision boundary based on the model
    P = model.decision_function(xy).reshape(X.shape)
    
    # plot decision boundary
    ax.contour(X, Y, P,
               levels=[0], alpha=0.5,
               linestyles=['-'])

You have everything you need to plot the decision boundary for this non-linear data. We can do that with a few lines of code that use the Matlibplot library, just like the other plots.

您具有绘制此非线性数据的决策边界所需的一切。 我们可以使用几行使用Matlibplot库的代码来做到这一点 ，就像其他绘图一样。

# plot data and decision boundary
plt.scatter(circle_X[:, 0], circle_X[:, 1], c=circle_y, s=50)
plot_decision_boundary(nonlinear_clf)
plt.scatter(nonlinear_clf.support_vectors_[:, 0], nonlinear_clf.support_vectors_[:, 1], s=50, lw=1, facecolors='none')
plt.show()

When you have your data and you know the problem you're trying to solve, it really can be this simple.

当您拥有数据并知道要解决的问题时，实际上就可以这么简单。

You can change your training model completely, you can choose different algorithms and features to work with, and you can fine tune your results based on multiple parameters. There are libraries and packages for all of this now so there's not a lot of math you have to deal with.

您可以完全更改训练模型，可以选择要使用的不同算法和功能，还可以基于多个参数对结果进行微调。 现在有用于所有这些功能的库和程序包，因此您不必处理很多数学。

现实世界问题的提示 (Tips for real world problems)

Real world datasets have some common issues because of how large they can be, the varying data types they hold, and how much computing power they can need to train a model.

现实世界中的数据集存在一些常见问题，因为它们的大小，所持有的数据类型不同以及训练模型需要多少计算能力。

There are a few things you should watch out for with SVMs in particular:

使用SVM时应特别注意以下几点：

• Make sure that your data are in numeric form instead of categorical form. SVMs expect numbers instead of other kinds of labels.
  确保您的数据采用数字形式而非分类形式。 SVM需要数字而不是其他类型的标签。
• Avoid copying data as much as possible. Some Python libraries will make duplicates of your data if they aren't in a specific format. Copying data will also slow down your training time and skew the way your model assigns the weights to a specific feature.
  尽量避免复制数据。 如果某些Python库的格式不是特定格式，则会将其复制。 复制数据还会减慢您的训练时间，并会扭曲模型将权重分配给特定功能的方式。
• Watch your kernel cache size because it uses your RAM. If you have a really large dataset, this could cause problems for your system.
  注意内核缓存的大小，因为它使用了RAM。 如果您的数据集非常大，则可能会给系统造成问题。
• Scale your data because SVM algorithms aren't scale invariant. That means you can convert all of your data to be within the ranges of [0, 1] or [-1, 1].
  缩放数据，因为SVM算法不是缩放不变的。 这意味着您可以将所有数据转换为[0，1]或[-1，1]范围内。

其他想法 (Other thoughts)

You might wonder why I didn't go into the deep details of the math here. It's mainly because I don't want to scare people away from learning more about machine learning.

您可能想知道为什么我在这里没有深入了解数学的细节。 这主要是因为我不想让人们远离对机器学习的更多了解。

It's fun to learn about those long, complicated math equations and their derivations, but it's rare you'll be writing your own algorithms and writing proofs on real projects.

了解那些冗长而复杂的数学方程式及其推导是一件很有趣的事情，但是很少有人会编写自己的算法并在实际项目中编写证明。

It's like using most of the other stuff you do every day, like your phone or your computer. You can do everything you need to do without knowing the how the processors are built.

这就像每天使用您做的大多数其他事情一样，例如您的手机或计算机。 您可以做所有需要做的事情而无需知道处理器的构建方式。

Machine learning is like any other software engineering application. There are a ton of packages that make it easier for you to get the results you need without a deep background in statistics.

机器学习就像其他任何软件工程应用程序一样。 有大量的软件包可以使您更轻松地获得所需的结果，而无需深厚的统计背景。

Once you get some practice with the different packages and libraries available, you'll find out that the hardest part about machine learning is getting and labeling your data.

一旦对可用的不同包和库进行了练习，您将发现关于机器学习的最困难的部分是获取和标记数据。

I'm working on a neuroscience, machine learning, web-based thing! You should follow me on Twitter to learn more about it and other cool tech stuff.

我正在研究神经科学，机器学习，基于Web的东西！ 您应该在Twitter上关注我，以了解有关它和其他炫酷技术的更多信息。

翻译自: https://www.freecodecamp.org/news/svm-machine-learning-tutorial-what-is-the-support-vector-machine-algorithm-explained-with-code-examples/

支持向量机svm代码实现