python实现几种常见机器学习算法

已于 2022-06-15 14:21:35 修改
阅读量385 收藏 1
点赞数
分类专栏： 机器学习 python 文章标签： python 机器学习 算法
于 2022-06-15 11:33:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24285815/article/details/125293995
版权

自己实现的LR、SVM、XGBOOST算法，记录一下。

# -*- coding: utf-8 -*-

"""
project: Tag Embedding
author:
date:
"""

import os
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt

from sklearn import linear_model
from sklearn import svm
from sklearn.preprocessing import label_binarize
from sklearn.metrics import roc_curve, roc_auc_score, auc, plot_roc_curve
from sklearn.model_selection import KFold
import xgboost as xgb

main_path = os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(os.path.dirname(__file__)))))
res_path = main_path + "/tag_similarity"
tag_path = res_path + "/tag_expand_embedding.xls"
tag_candidate = res_path + "/tag_sim_pred_candidate.xls"


def plot_res(x, y, color=None, linewidth=None):
    if linewidth is None:
        plt.scatter(x, y, color=color)
    else:
        plt.plot(x, y, color=color, linewidth=linewidth)

    plt.xticks(np.arange(0, 0.5, 0.1))
    plt.yticks(np.arange(0, 1, 0.1))


class Normalization(object):

    def __init__(self, df):
        self.df = df.replace('\\N', 0).replace('-', '-')

    def min_max_norm(self):
        norm_df = self.df.apply(lambda x: (x - np.min(x)) / (np.max(x) - np.min(x)))
        return norm_df

    def mean_norm(self):
        norm_df = self.df.apply(lambda x: (x - np.mean(x)) / (np.max(x) - np.min(x)))
        return norm_df

    def z_score_norm(self):
        norm_df = self.df.apply(lambda x: (x - np.mean(x)) / np.std(x))
        return norm_df


class ReadData(object):

    def __init__(self, read_path):
        self.read_path = read_path

    def read_origin_data(self):
        origin_data = pd.read_excel(self.read_path)
        sample = origin_data[(origin_data.coa >= 0.07) | (origin_data.cos_sim >= 0.65)].sample(frac=1).reset_index(
            drop=True)
        # sample['cos_sim'] = sample['cos_sim'].apply(lambda x: 1-x)
        return sample

    def read_train_test_data(self):
        sample = self.read_origin_data()
        train_sample = sample[:(len(sample) // 3) * 2]
        test_sample = sample[(len(sample) // 3) * 2:]
        return train_sample, test_sample


class SimpleClassification(object):

    def __init__(self, train_sample, test_sample):
        self.train_sample = train_sample
        self.test_sample = test_sample

    def sample_extract(self):
        pos_train = self.train_sample.query("old_flag != 0 & old_flag != 1 & new_flag != 0 & new_flag != 1")
        neu_train = self.train_sample.query("(old_flag == 1 & new_flag != 0) | (old_flag != 0 & new_flag == 1)")
        neg_train = self.train_sample.query("old_flag == 0 | new_flag == 0")
        pos_test = self.test_sample.query("old_flag != 0 & old_flag != 1 & new_flag != 0 & new_flag != 1")
        neu_test = self.test_sample.query("(old_flag == 1 & new_flag != 0) | (old_flag != 0 & new_flag == 1)")
        neg_test = self.test_sample.query("old_flag == 0 | new_flag == 0")
        return pos_train, neu_train, neg_train, pos_test, neu_test, neg_test

    def sample_distribution(self):
        pos_data = pd.concat([self.sample_extract()[0], self.sample_extract()[3]])
        pos_sample = pos_data[['coa', 'cos_sim']]
        pos_sample_array = pos_sample.values
        plot_res(pos_sample_array[:, 0], pos_sample_array[:, 1], color='orange')

        neu_data = pd.concat([self.sample_extract()[1], self.sample_extract()[4]])
        neu_sample = neu_data[['coa', 'cos_sim']]
        neu_sample_array = neu_sample.values
        plot_res(neu_sample_array[:, 0], neu_sample_array[:, 1], color='blue')

        neg_data = pd.concat([self.sample_extract()[2], self.sample_extract()[5]])
        neg_sample = neg_data[['coa', 'cos_sim']]
        neg_sample_array = neg_sample.values
        plot_res(neg_sample_array[:, 0], neg_sample_array[:, 1], color='green')
        plt.show()

    def linear_regression(self, test_number):
        pos_data = pd.concat([self.sample_extract()[0], self.sample_extract()[3]])
        pos_sample = pos_data[['coa', 'cos_sim']]
        pos_sample_array = pos_sample.values
        regr = linear_model.LinearRegression()
        train_end = test_number * (-1)
        regr.fit(pos_sample_array[:train_end, 0].reshape(-1, 1), pos_sample_array[:train_end, 1].reshape(-1, 1))
        regr_pred = regr.predict(pos_sample_array[train_end:, 0].reshape(-1, 1))
        plot_res(pos_sample_array[train_end:, 0].reshape(-1, 1), pos_sample_array[train_end:, 1].reshape(-1, 1),
                 color='black')
        plot_res(pos_sample_array[train_end:, 0].reshape(-1, 1), regr_pred, color='blue', linewidth=3)
        plt.show()

    def svm_classification(self):
        train_data = pd.concat([self.sample_extract()[0], self.sample_extract()[1], self.sample_extract()[2]])
        train_sample = train_data[['coa', 'euclid_dist', 'cos_sim', 'kl_div']]
        train_sample_norm = Normalization(train_sample).z_score_norm()
        train_sample_array = train_sample_norm.values
        train_index = [1] * len(self.sample_extract()[0]) + [0] * len(self.sample_extract()[1]) + [-1] * len(
            self.sample_extract()[2])
        train_sample_weight = train_data['clk_conf'].values.tolist()

        test_data = pd.concat([self.sample_extract()[3], self.sample_extract()[4], self.sample_extract()[5]])
        test_sample = test_data[['coa', 'euclid_dist', 'cos_sim', 'kl_div']]
        test_sample_norm = Normalization(test_sample).z_score_norm()
        test_sample_array = test_sample_norm.values
        test_index = [1] * len(self.sample_extract()[3]) + [0] * len(self.sample_extract()[4]) + [-1] * len(
            self.sample_extract()[5])

        # clf = svm.SVC(gamma='scale', decision_function_shape='ovo',
        #               class_weight={
        #                   -1: len(train_sample) / (len(set(train_index)) * len(self.sample_extract()[2])) * 1.5,
        #                   0: len(train_sample) / (len(set(train_index)) * len(self.sample_extract()[1])) * 0.9,
        #                   1: len(train_sample) / (len(set(train_index)) * len(self.sample_extract()[0]))
        #               }
        # )
        clf = svm.SVC(gamma='scale', decision_function_shape='ovo', class_weight='balanced')
        clf.fit(X=train_sample_array, y=train_index, sample_weight=train_sample_weight)
        clf_pred = clf.predict(test_sample_array)
        clf_dec = clf.decision_function(test_sample_array)

        # 绘制每个类别的ROC曲线
        fig, axes = plt.subplots(2, 2, figsize=(8, 8))
        colors = ["r", "g", "b", "k"]
        markers = ["o", "^", "v", "+"]

        y_test = label_binarize(test_index, classes=clf.classes_)
        for i in range(len(clf.classes_)):
            # 计算每个类别的FPR, TPR
            fpr, tpr, thr = roc_curve(y_test[:, i], clf_dec[:, i])
            #     print("classes_{}, fpr: {}, tpr: {}, threshold: {}".format(i, fpr, tpr, thr))
            # 绘制ROC曲线，并计算AUC值
            axes[int(i / 2), i % 2].plot(fpr, tpr, color=colors[i], marker=markers[i],
                                         label="AUC: {:.2f}".format(auc(fpr, tpr)))
            axes[int(i / 2), i % 2].set_xlabel("FPR")
            axes[int(i / 2), i % 2].set_ylabel("TPR")
            axes[int(i / 2), i % 2].set_title("Class_{}".format(clf.classes_[i]))
            axes[int(i / 2), i % 2].legend(loc="lower right")

        print("AUC:", roc_auc_score(y_test, clf_dec, multi_class="ovo", average=None))

        # 输出预测结果
        test_res_df = test_data
        test_res_df['test_index'] = test_index
        test_res_df['clf_pred'] = clf_pred
        test_res_df.to_excel('test_res.xlsx')

        return test_res_df

    def xgb_classification_3(self):
        train_data = pd.concat([self.sample_extract()[0], self.sample_extract()[1], self.sample_extract()[2]])
        train_sample = train_data[['coa', 'euclid_dist', 'cos_sim', 'kl_div', 'clk_coa', 'clk_conf_1', 'clk_conf_2']]
        train_sample_norm = Normalization(train_sample).min_max_norm()
        train_sample_array = train_sample_norm.values
        train_index = [2] * len(self.sample_extract()[0]) + [1] * len(self.sample_extract()[1]) + [0] * len(
            self.sample_extract()[2])
        # train_sample_weight = train_data['clk_conf_1'].replace('\\N', 0).values.tolist()
        # xgb_train = xgb.DMatrix(train_sample_array, label=np.array(train_index), weight=np.array(train_sample_weight), missing=-1.0)
        xgb_train = xgb.DMatrix(train_sample_array, label=np.array(train_index), missing=-999.0)

        test_data = pd.concat([self.sample_extract()[3], self.sample_extract()[4], self.sample_extract()[5]])
        test_sample = test_data[['coa', 'euclid_dist', 'cos_sim', 'kl_div', 'clk_coa', 'clk_conf_1', 'clk_conf_2']]
        test_sample_norm = Normalization(test_sample).min_max_norm()
        test_sample_array = test_sample_norm.values
        test_index = [2] * len(self.sample_extract()[3]) + [1] * len(self.sample_extract()[4]) + [0] * len(
            self.sample_extract()[5])
        xgb_test = xgb.DMatrix(test_sample_array)

        params = {
            'booster': 'gbtree',
            'objective': 'multi:softprob',
            'num_class': 3,
            'gamma': 0.1,
            'max_depth': 3,
            'lambda': 0.1,
            'subsample': 0.8,
            'colsample_bytree': 0.8,
            'min_child_weight': 2,
            'max_delta_step': 2,
            'alpha': 0.1,
            'eta': 0.1,
            'seed': 1000,
            'nthread': 2,
        }

        # cv = KFold(n_splits=5, shuffle=True, random_state=100)
        # r = xgb.cv(params=params, dtrain=xgb_train, num_boost_round=300, folds=cv, metrics='mlogloss')
        # print(r)
        evallist = [(xgb_train, 'train')]
        bst_model = xgb.train(params=params, dtrain=xgb_train, num_boost_round=200, evals=evallist)

        xgb_pred_prob = bst_model.predict(xgb_test)
        xgb_pred = []
        for prob in xgb_pred_prob:
            xgb_pred.append(np.argmax(prob))
        bst_model.save_model('tag_sim_bst_model')
        bst_model.dump_model('dump.raw.txt')

        # 计算准确率
        cnt1 = 0
        cnt2 = 0
        for i in range(len(test_index)):
            if xgb_pred[i] == test_index[i]:
                cnt1 += 1
            else:
                cnt2 += 1
        print("Accuracy: %.2f %% " % (100 * cnt1 / (cnt1 + cnt2)))

        # 显示重要特征
        # xgb.plot_importance(bst_model)
        # plt.show()

        fpr, tpr, thresholds = roc_curve(y_true=np.array(test_index), y_score=xgb_pred, pos_label=2)
        roc_auc = auc(fpr, tpr)
        print("AUC: %.2f" % roc_auc)
        # plt.plot(fpr, tpr, lw=1, label='ROC (area = %0.6f)' % roc_auc)

        # 输出预测结果
        test_res_df = test_data
        test_res_df['test_index'] = test_index
        test_res_df['xgb_pred_prob'] = list(xgb_pred_prob)
        test_res_df['xgb_pred'] = xgb_pred
        test_res_df.to_excel('xgb_test_res.xlsx')
        return test_res_df

    def xgb_classification_2(self):
        train_data = pd.concat(
            [self.sample_extract()[0], self.sample_extract()[1], self.sample_extract()[1], self.sample_extract()[2]])
        train_sample = train_data[['coa', 'euclid_dist', 'cos_sim', 'kl_div', 'clk_coa', 'clk_conf_1', 'clk_conf_2']]
        train_sample_norm = Normalization(train_sample).min_max_norm()
        train_sample_array = train_sample_norm.values
        train_index = [1] * len(self.sample_extract()[0]) + [1] * len(self.sample_extract()[1]) + [0] * len(self.sample_extract()[1]) + [0] * len(self.sample_extract()[2])
        train_sample_weight = train_data['clk_conf_1'].values.tolist()
        # xgb_train = xgb.DMatrix(train_sample_array, label=np.array(train_index), weight=np.array(train_sample_weight))
        xgb_train = xgb.DMatrix(train_sample_array, label=np.array(train_index), missing=-999.0)

        test_data = pd.concat(
            [self.sample_extract()[3], self.sample_extract()[4],  self.sample_extract()[4], self.sample_extract()[5]])
        test_sample = test_data[['coa', 'euclid_dist', 'cos_sim', 'kl_div', 'clk_coa', 'clk_conf_1', 'clk_conf_2']]
        test_sample_norm = Normalization(test_sample).min_max_norm()
        test_sample_array = test_sample_norm.values
        test_index = [1] * len(self.sample_extract()[3]) + [1] * len(self.sample_extract()[4]) + [0] * len(self.sample_extract()[4]) + [0] * len(self.sample_extract()[5])
        xgb_test = xgb.DMatrix(test_sample_array)

        params = {
            'booster': 'gbtree',
            'objective': 'binary:logistic',
            # 'num_class': 2,
            'gamma': 0.1,
            'max_depth': 4,
            'lambda': 2,
            'subsample': 0.8,
            'colsample_bytree': 0.8,
            'min_child_weight': 3,
            'max_delta_step': 2,
            'alpha': 0.005,
            'eta': 0.1,
            'seed': 1000,
            'nthread': 2,
            # 'scale_pos_weight': (len(self.sample_extract()[2])) / (len(self.sample_extract()[0]) + len(self.sample_extract()[1])),
        }

        # cv = KFold(n_splits=5, shuffle=True, random_state=100)
        # r = xgb.cv(params=params, dtrain=xgb_train, num_boost_round=200, folds=cv, metrics='mlogloss')
        # print(r)
        evallist = [(xgb_train, 'train')]
        bst_model = xgb.train(params=params, dtrain=xgb_train, num_boost_round=200, evals=evallist)

        xgb_pred_prob = bst_model.predict(xgb_test)
        xgb_pred = np.where(xgb_pred_prob >= 0.5, 1, 0)
        bst_model.save_model('tag_sim_bst_model')
        bst_model.dump_model('dump.raw.txt')

        # 计算准确率
        cnt1 = 0
        cnt2 = 0
        for i in range(len(test_index)):
            if xgb_pred[i] == test_index[i]:
                cnt1 += 1
            else:
                cnt2 += 1
        print("Accuracy: %.2f %% " % (100 * cnt1 / (cnt1 + cnt2)))

        # 显示重要特征
        # xgb.plot_importance(bst_model)
        # plt.show()

        fpr, tpr, thresholds = roc_curve(y_true=np.array(test_index), y_score=xgb_pred, pos_label=1)
        roc_auc = auc(fpr, tpr)
        print("AUC: %.2f" % roc_auc)
        # plt.plot(fpr, tpr, lw=1, label='ROC (area = %0.6f)' % roc_auc)

        # 输出预测结果
        test_res_df = test_data
        test_res_df['test_index'] = test_index
        test_res_df['xgb_pred'] = xgb_pred
        test_res_df.to_excel('xgb_test_res.xlsx')
        return test_res_df


class PredictTagSimilarity(object):

    def __init__(self, model, pred_candidate):
        self.model = model
        self.pred_cand = pred_candidate

    def xgb_pred_3(self):
        pred_data = self.pred_cand[['coa', 'euclid_dist', 'cos_sim', 'kl_div', 'clk_coa', 'clk_conf_1', 'clk_conf_2']]
        pred_data_norm = Normalization(pred_data).min_max_norm()
        pred_data_norm_array = pred_data_norm.values
        pred_data_xgb = xgb.DMatrix(pred_data_norm_array, missing=-999.0)

        bst = xgb.Booster({'nthread': 2})  # init model
        bst.load_model(self.model)  # load data
        bst_pred_prob = bst.predict(pred_data_xgb)
        bst_pred_pro0, bst_pred_pro1, bst_pred_pro2, bst_pred = [], [], [], []
        for prob in bst_pred_prob:
            bst_pred_pro0.append(prob[0])
            bst_pred_pro1.append(prob[1])
            bst_pred_pro2.append(prob[2])
            bst_pred.append(np.argmax(prob))

        # 输出预测结果
        res_df = self.pred_cand
        res_df['bst_pred_prob'] = list(bst_pred_prob)
        res_df['bst_pred_pro0'] = bst_pred_pro0
        res_df['bst_pred_pro1'] = bst_pred_pro1
        res_df['bst_pred_pro2'] = bst_pred_pro2
        res_df['bst_pred'] = bst_pred
        res_df.to_excel('xgb_pred_res.xlsx')
        return res_df

    def xgb_pred_2(self):
        pred_data = self.pred_cand[['coa', 'euclid_dist', 'cos_sim', 'kl_div', 'clk_coa', 'clk_conf_1', 'clk_conf_2']]
        pred_data_norm = Normalization(pred_data).min_max_norm()
        pred_data_norm_array = pred_data_norm.values
        pred_data_xgb = xgb.DMatrix(pred_data_norm_array, missing=-999.0)

        bst = xgb.Booster({'nthread': 2})  # init model
        bst.load_model(self.model)  # load data
        bst_pred_prob = bst.predict(pred_data_xgb)
        bst_pred = np.where(bst_pred_prob >= 0.5, 1, 0)

        # 输出预测结果
        res_df = self.pred_cand
        res_df['bst_pred_prob'] = list(bst_pred_prob)
        res_df['bst_pred'] = bst_pred
        res_df.to_excel('xgb_pred_res.xlsx')
        return res_df


if __name__ == "__main__":
    # print(ReadData(tag_path).read_train_test_data()[1])
    train_datas = ReadData(tag_path).read_train_test_data()[0]
    test_datas = ReadData(tag_path).read_train_test_data()[1]

    # SimpleClassification(train_datas, test_datas).sample_distribution()

    # SimpleClassification(train_datas, test_datas).linear_regression(test_number=40)

    # SimpleClassification(train_datas, test_datas).svm_classification()
    # plt.show()

    # SimpleClassification(train_datas, test_datas).xgb_classification_3()

    pred_datas = pd.read_excel(tag_candidate)
    PredictTagSimilarity(pred_candidate=pred_datas, model="tag_sim_bst_model").xgb_pred_3()
z語默
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用python实现几种机器学习算法.zip
02-22
用python实现几种机器学习算法
机器学习十大算法实现python代码汇总
qq_43115961的博客
09-14 4449
机器学习十大算法实现python代码汇总
Python入门之机器学习（非常详细）篇幅拉满，一般人看不完！
python03012的博客
02-29 540
文末可免费领取2024最新全套Python资料 一、什么是机器学习 什么是机器学习？机器学习其实就是想让计算机像人一样思考而研发出的计算机理论，目前常用的机器学习有以下几种算法： 监督学习 supervised learning; 非监督学习 unsupervised learning; 半监督学习 semi-supervised learning; 强化学习 reinforcement learning; 监督学习是不断向计算机提供数据（特征），并告诉计算机对应的值（标签），最后通过大量的数据，让计算
小姐姐带你一起学：如何用Python实现7种机器学习算法（附代码）
热门推荐
AI科技大本营
03-30 2万+
编译 | 林椿眄出品 | AI科技大本营（公众号ID：rgznai100）【AI科技大本营导读】Python 被称为是最接近 AI 的语言。最近一位名叫Anna-Lena Popkes的小姐姐在GitHub上分享了自己如何使用Python（3.6及以上版本）实现7种机器学习算法的笔记，并附有完整代码。所有这些算法的实现都没有使用其他机器学习库。这份笔记可以帮大家对算法以及其底层结构有个基本的了解，
机器学习十大算法实现代码汇总（python）----线性回归、逻辑回归、决策树、支持向量机、朴素贝叶斯、K邻近算法、K-均值算法、随机森林、降低维度算法、梯度增强算法
weixin_43580130的博客
08-06 3577
目录引入一、线性回归 (Linear Regression)二、逻辑回归 (Logistic Regression)三、决策树 (Decision Tree)四、支持向量机算法 (Support Vector Machine,SVM)五、K邻近算法（K-Nearest Neighbors，KNN）六、K-均值算法（K-means）七、朴素贝叶斯 (Naive Bayes)八、随机森林 (Random Forest)九、降低维度算法（Dimensionality Reduction）十、梯度增强算法Gradi
10 种机器学习算法的要点（附 Python 和 R 代码）
onlyForCloud的专栏
10-08 5161
http://blog.jobbole.com/92021/ 本文由 伯乐在线 - Agatha 翻译，唐尤华 校稿。未经许可，禁止转载！ 英文出处：SUNIL RAY。欢迎加入翻译组。 前言 谷歌董事长施密特曾说过：虽然谷歌的无人驾驶汽车和机器人受到了许多媒体关注，但是这家公司真正的未来在于机器学习，一种让计算机更聪明、更个性化的技术。 也许我们生活在人
8种顶级Python机器学习算法-你必须学习
weixin_33755554的博客
08-27 339
今天，我们将更深入地学习和实现8个顶级Python机器学习算法。 让我们开始Python编程中的机器学习算法之旅。 8种顶级Python机器学习算法-你必须学习 8 Python机器学习算法 - 你必须学习 以下是Python机器学习的算法： 1。线性回归 线性回归是受监督的Python机器学习算法之一，它可以观察连续特征并预测结果。根据它是在单个变量上还是在许多特征上运行，我们可以将其称为简单线...
python算法学习代码_入门十大 Python 机器学习算法 (附代码)
weixin_39947396的博客
12-05 229
入门十大 Python 机器学习算法 (附代码)1 线性回归线性回归通常用于根据连续变量估计实际数值 (房价呼叫次数总销售额等) 我们通过拟合最佳直线来建立自变量和因变量的关系这条最佳直线叫做回归线, 并且用 Y= a *X + b 这条线性等式来表示理解线性回归的最好办法是回顾一下童年假设在不问对方体重的情况下, 让一个五年级的孩子按体重从轻到重的顺序对班上的同学排序, 你觉得这个孩子会怎么做?...
毕业设计作业-解释什么是机器学习，并列举几种常见的机器学习算法 并以python附上代码实例.pdf
07-18
毕业设计作业—解释什么是机器学习，并列举几种常见的机器学习算法。并以python附上代码实例
Python机器学习库sklearn几种回归算法建模及分析实验
12-23
sklearn库，Python机器学习库sklearn几种回归算法建模及分析实验，Python机器学习库sklearn⼏种回归算法建模及分析（实验）最简单的回归模型就是线性回归
文档Python机器学习库sklearn几种回归算法建模及分析
最新发布
04-17
文档Python机器学习库sklearn几种回归算法建模及分析实验提取方式是百度网盘分享地址
python应该掌握的几种算法.docx
06-12
python应该掌握的几种算法 Python是一种高级编程语言，广泛应用于数据科学、机器学习、人工智能等领域。在Python中，有许多重要的算法，掌握这些算法对于编写高效的程序和解决实际问题非常重要。本文将介绍Python...
机器学习10大经典算法 python实现
linzengmin的博客
06-30 738
1、svm（支持向量机）： from sklearn.datasets import load_iris import numpy as np from sklearn.metrics import accuracy_score from sklearn import svm from sklearn.model_selection import train_test_split if __name__ == '__main__': allPre=[] for i in range(1
python --机器学习(基本算法详解)SciPy、Numpy、Matplotlib
weixin_44634704的博客
08-11 1万+
数据集在计算机中，数据集指的是任何数据集合。它可以是从数组到完整数据库的任何内容。通过查看数组，我们可以猜测平均值可能约为 80 或 90，并且我们还可以确定最大值和最小值，但是我们还能做什么？通过查看数据库，我们可以看到最受欢迎的颜色是白色，最老的车龄是 17 年，但是如果仅通过查看其他值就可以预测汽车是否具有 AutoPass，该怎么办？这就是机器学习的目的！分析数据并预测结果！在机器学习中，通常使用非常大的数据集。...............
python常用代码入门-入门十大Python机器学习算法（附代码）
q6q6q的专栏
10-28 709
入门十大Python机器学习算法（附代码）今天，给大家推荐最常用的10种机器学习算法，它们几乎可以用在所有的数据问题上：1、线性回归线性回归通常用于根据连续变量估计实际数值（房价、呼叫次数、总销售额等）。我们通过拟合最佳直线来建立自变量和因变量的关系。这条最佳直线叫做回归线，并且用 Y= a *X + b 这条线性等式来表示。理解线性回归的最好办法是回顾一下童年。假设在不问对方体重的情况下，让一个...
【Python入门系列】第十一篇：Python机器学习入门
JosieBook
07-05 2204
机器学习是人工智能领域中的重要分支，它利用数据和统计方法来训练机器模型，从而实现自动化的决策和预测。Python作为一种简单易用且功能强大的编程语言，成为了机器学习领域的首选工具之一。本文将介绍Python机器学习的基础知识和常用库。机器学习是一种人工智能的分支，通过利用数据和统计算法，让计算机能够自动学习和改进，从而完成特定任务。以下是机器学习的作用总结：预测和分类：机器学习可以通过对历史数据的学习，预测未来事件的发生概率，或将数据分为不同的类别。
如何使用 Python 进行机器学习？
技术专家
05-30 1843
​ 全套学习路线图、课程，机器学习工作流程如下。 Python+人工智能 入门： Python基础→Python数据挖掘 中级： 机器学习 进阶： NLP自然语言 高级： OpenCV基础→深度学习 ​
Python机器学习：认识机器学习
weixin_62917800的博客
01-13 1464
记录机器学习的第一次笔记~~~~
关于机器学习算法的python来实现
09-06
使用Python进行机器学习算法的实现有以下几个步骤。 首先，导入所需的库。Python有许多机器学习库，如scikit-learn、TensorFlow和PyTorch。根据算法的需求，选择合适的库。 第二步是数据预处理。这个步骤对数据...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值