PSG机器学习

最新推荐文章于 2024-10-15 21:19:38 发布
最新推荐文章于 2024-10-15 21:19:38 发布
阅读量146 收藏
点赞数 1
文章标签： 机器学习 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45779564/article/details/137637983
版权

使用Python-EEG工具库MNE-机器学习算法随机森林、SVM、逻辑回归、KNN、朴素贝叶斯、多层感知机、LSTM等方法判断睡眠类型

import numpy as np
import matplotlib.pyplot as plt

import mne

from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
from sklearn.metrics import confusion_matrix
from sklearn.metrics import classification_report
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import FunctionTransformer
"""
可以通过
mne.datasets.sleep_physionet.age.fetch_data(subjects,recording,path)
来获取PhysioNet多导睡眠图数据集文件。
subjects：表示想要使用哪些受试者对象，可供选择的受试者对象范围为0-19。
recording：表示夜间记录的编号(索引)，有效值为：[1]、[2]或[1、2]。

path:PhysioNet数据的存放地址，如果没有给定，则加载默认存放数据的地址；
如果默认存放数据集的地址不存在数据，则从网络中下载相关数据。
"""

# 选择两个受试者实验对象ALICE, BOB(该名字并非实验中的真实名，这里是为了方便才临时取的名字)
ALICE, BOB = 0, 1
# 加载ALICE, BOB的实验数据文件
[alice_files, bob_files] = mne.datasets.sleep_physionet.age.fetch_data(subjects=[ALICE, BOB], recording=[1])

# 通道名称映射
mapping = {'EOG horizontal': 'eog',
           'Resp oro-nasal': 'misc',
           'EMG submental': 'misc',
           'Temp rectal': 'misc',
           'Event marker': 'misc'}

#读取ALICE的edf文件，和其对应的注释文件
raw_train = mne.io.read_raw_edf(alice_files[0])
annot_train = mne.read_annotations(alice_files[1])

raw_train.set_annotations(annot_train, emit_warning=False)
raw_train.set_channel_types(mapping)

# 绘制空0s开始，时间窗口长度为40s的连续通道数据波形图
raw_train.plot(duration=40, scalings='auto')
plt.show()

"""
睡眠表示与事件映射
"""
annotation_desc_2_event_id = {'Sleep stage W': 1,
                              'Sleep stage 1': 2,
                              'Sleep stage 2': 3,
                              'Sleep stage 3': 4,
                              'Sleep stage 4': 4,
                              'Sleep stage R': 5}

events_train, _ = mne.events_from_annotations(
    raw_train, event_id=annotation_desc_2_event_id, chunk_duration=30.)

# 创建一个新的event_id以统一 阶段3和4
event_id = {'Sleep stage W': 1,
            'Sleep stage 1': 2,
            'Sleep stage 2': 3,
            'Sleep stage 3/4': 4,
            'Sleep stage R': 5}

# 绘制事件数据
mne.viz.plot_events(events_train, event_id=event_id,
                    sfreq=raw_train.info['sfreq'])

# 保留颜色代码以便进一步绘制
stage_colors = plt.rcParams['axes.prop_cycle'].by_key()['color']
Used Annotations descriptions: ['Sleep stage 1', 'Sleep stage 2', 'Sleep stage 3', 'Sleep stage 4', 'Sleep stage R', 'Sleep stage W']

tmax = 30. - 1. / raw_train.info['sfreq']  # tmax in included
"""
所创建的是时间从tmin=0开始，到tmax为止的epochs
"""
epochs_train = mne.Epochs(raw=raw_train, events=events_train,
                          event_id=event_id, tmin=0., tmax=tmax, baseline=None)

print(epochs_train)


epochs_test = mne.Epochs(raw=raw_test, events=events_test, event_id=event_id,
                         tmin=0., tmax=tmax, baseline=None)

print(epochs_test)

fig, (ax1, ax2) = plt.subplots(ncols=2)

# iterate over the subjects
stages = sorted(event_id.keys())
for ax, title, epochs in zip([ax1, ax2],
                             ['Alice', 'Bob'],
                             [epochs_train, epochs_test]):

    for stage, color in zip(stages, stage_colors):
        epochs[stage].plot_psd(area_mode=None, color=color, ax=ax,
                               fmin=0.1, fmax=20., show=False,
                               average=True, spatial_colors=False)
    ax.set(title=title, xlabel='Frequency (Hz)')
ax2.set(ylabel='uV^2/hz (dB)')
ax2.legend(ax2.lines[2::3], stages)
plt.tight_layout()
plt.show()


from mne.time_frequency import psd_array_welch

def eeg_power_band(epochs):
    """脑电相对功率带特征提取
    该函数接受一个 'mne.Epochs' 对象，
    并基于与 scikit-learn 兼容的特定频带中的相对功率创建 EEG 特征。
    Parameters
    ----------
    epochs : mne.Epochs
        The data.
    Returns
    -------
    X : numpy array of shape [n_samples, 5]
        Transformed data.
    """
    # 特定频带
    FREQ_BANDS = {"delta": [0.5, 4.5],
                  "theta": [4.5, 8.5],
                  "alpha": [8.5, 11.5],
                  "sigma": [11.5, 15.5],
                  "beta": [15.5, 30]}

    # 提取 EEG 数据的 numpy 表示
    epochs_data = epochs.get_data()

    psds, freqs = psd_array_welch(epochs_data, sfreq=epochs.info['sfreq'], fmin=0.5, fmax=30.)
    psds /= np.sum(psds, axis=-1, keepdims=True)

    X = []
    for fmin, fmax in FREQ_BANDS.values():
        psds_band = psds[:, :, (freqs >= fmin) & (freqs < fmax)].mean(axis=-1)
        X.append(psds_band.reshape(len(psds), -1))

    return np.concatenate(X, axis=1)
pipe = make_pipeline(FunctionTransformer(eeg_power_band, validate=False),
                     RandomForestClassifier(n_estimators=100, random_state=100))
# 训练
epochs_train.load_data()

y_train = epochs_train.events[:, 2]
pipe.fit(epochs_train, y_train)

# 预测
y_pred = pipe.predict(epochs_test)

# 评估准确率
y_test = epochs_test.events[:, 2]
acc = accuracy_score(y_test, y_pred)

print("Accuracy score: {}".format(acc))
#Loading data for 2650 events and 3000 original #time points ...
#0 bad epochs dropped
#Effective window size : 2.560 (s)
#Loading data for 2802 events and 3000 original time points ...
#0 bad epochs dropped
#Effective window size : 2.560 (s)
#Accuracy score: 0.8344039971448965

print(classification_report(y_test, y_pred, target_names=event_id.keys()))
#                 precision    recall  f1-score   #support
#
#  Sleep stage W       0.83      1.00      0.91      #1856
#  Sleep stage 1       0.00      0.00      0.00       109
#  Sleep stage 2       0.94      0.62      0.74       562
#Sleep stage 3/4       0.74      0.95      0.83       105
#  Sleep stage R       0.56      0.21      0.31       170

#       accuracy                           0.83      2802
#      macro avg       0.61      0.56      0.56      2802
#   weighted avg       0.80      0.83      0.80      2802

from sklearn.svm import SVC
# 创建流水线
pipe = make_pipeline(FunctionTransformer(eeg_power_band, validate=False),
                     SVC(kernel='linear'))  # 使用线性核函数，你也可以尝试其他核函数

# 训练
epochs_train.load_data()

y_train = epochs_train.events[:, 2]
pipe.fit(epochs_train, y_train)

# 预测
y_pred = pipe.predict(epochs_test)

# 评估准确率
y_test = epochs_test.events[:, 2]
acc = accuracy_score(y_test, y_pred)

print("Accuracy score: {}".format(acc))
#Effective window size : 2.560 (s)
#Loading data for 2802 events and 3000 original #time #points ...
#Effective window size : 2.560 (s)
#Accuracy score: 0.662384011420414

from sklearn.svm import SVC
# 创建流水线
pipe = make_pipeline(FunctionTransformer(eeg_power_band, validate=False),
                     SVC(kernel='poly'))  # 使用线性核函数，你也可以尝试其他核函数

# 训练
epochs_train.load_data()

y_train = epochs_train.events[:, 2]
pipe.fit(epochs_train, y_train)

# 预测
y_pred = pipe.predict(epochs_test)

# 评估准确率
y_test = epochs_test.events[:, 2]
acc = accuracy_score(y_test, y_pred)

print("Accuracy score: {}".format(acc))
#Effective window size : 2.560 (s)
#Loading data for 2802 events and 3000 original time #points ...
#Effective window size : 2.560 (s)
#Accuracy score: 0.7894361170592434

from sklearn.svm import SVC
# 创建流水线
pipe = make_pipeline(FunctionTransformer(eeg_power_band, validate=False),
                     SVC(kernel='rbf'))  # 使用线性核函数，你也可以尝试其他核函数

# 训练
epochs_train.load_data()

y_train = epochs_train.events[:, 2]
pipe.fit(epochs_train, y_train)

# 预测
y_pred = pipe.predict(epochs_test)

# 评估准确率
y_test = epochs_test.events[:, 2]
acc = accuracy_score(y_test, y_pred)

print("Accuracy score: {}".format(acc))
#Effective window size : 2.560 (s)
#Loading data for 2802 events and 3000 original time points ...
#Effective window size : 2.560 (s)
#Accuracy score: 0.7623126338329764

from sklearn.svm import SVC
# 创建流水线
pipe = make_pipeline(FunctionTransformer(eeg_power_band, validate=False),
                     SVC(kernel='sigmoid'))  # 使用线性核函数，你也可以尝试其他核函数

# 训练
epochs_train.load_data()

y_train = epochs_train.events[:, 2]
pipe.fit(epochs_train, y_train)

# 预测
y_pred = pipe.predict(epochs_test)

# 评估准确率
y_test = epochs_test.events[:, 2]
acc = accuracy_score(y_test, y_pred)

print("Accuracy score: {}".format(acc))
#Effective window size : 2.560 (s)
#Loading data for 2802 events and 3000 original time points ...
#Effective window size : 2.560 (s)
#Accuracy score: 0.6627408993576017

from sklearn.neighbors import KNeighborsClassifier
# 创建流水线
pipe = make_pipeline(FunctionTransformer(eeg_power_band, validate=False),
                     KNeighborsClassifier(n_neighbors=5))  # 设置邻居数，这里设为5，你也可以根据需求调整

# 训练
epochs_train.load_data()

y_train = epochs_train.events[:, 2]
pipe.fit(epochs_train, y_train)

# 预测
y_pred = pipe.predict(epochs_test)

# 评估准确率
y_test = epochs_test.events[:, 2]
acc = accuracy_score(y_test, y_pred)

print("Accuracy score: {}".format(acc))
#Effective window size : 2.560 (s)
#Loading data for 2802 events and 3000 original time points ...
#Effective window size : 2.560 (s)
#Accuracy score: 0.8194147037830122

from sklearn.linear_model import LogisticRegression

# 创建流水线
pipe = make_pipeline(FunctionTransformer(eeg_power_band, validate=False),
                     LogisticRegression(max_iter=1000))  # 设置最大迭代次数，确保模型收敛

# 训练
epochs_train.load_data()

y_train = epochs_train.events[:, 2]
pipe.fit(epochs_train, y_train)

# 预测
y_pred = pipe.predict(epochs_test)

# 评估准确率
y_test = epochs_test.events[:, 2]
acc = accuracy_score(y_test, y_pred)

print("Accuracy score: {}".format(acc))
#Effective window size : 2.560 (s)
#Loading data for 2802 events and 3000 original time points ...
#Effective window size : 2.560 (s)
#Accuracy score: 0.662384011420414

from sklearn.neural_network import MLPClassifier

# 创建流水线
pipe = make_pipeline(FunctionTransformer(eeg_power_band, validate=False),
                     MLPClassifier(hidden_layer_sizes=(100, ), max_iter=1000))  # 设置隐藏层大小和最大迭代次数

# 训练
epochs_train.load_data()

y_train = epochs_train.events[:, 2]
pipe.fit(epochs_train, y_train)

# 预测
y_pred = pipe.predict(epochs_test)

# 评估准确率
y_test = epochs_test.events[:, 2]
acc = accuracy_score(y_test, y_pred)

print("Accuracy score: {}".format(acc))
#Effective window size : 2.560 (s)
#Loading data for 2802 events and 3000 original time points ...
#Effective window size : 2.560 (s)
#Accuracy score: 0.8465381870092791

from sklearn.naive_bayes import GaussianNB

# 创建流水线
pipe = make_pipeline(FunctionTransformer(eeg_power_band, validate=False),
                     GaussianNB())

# 训练
epochs_train.load_data()

y_train = epochs_train.events[:, 2]
pipe.fit(epochs_train, y_train)

# 预测
y_pred = pipe.predict(epochs_test)

# 评估准确率
y_test = epochs_test.events[:, 2]
acc = accuracy_score(y_test, y_pred)

print("Accuracy score: {}".format(acc))
#Effective window size : 2.560 (s)
#Loading data for 2802 events and 3000 original time points ...
#Effective window size : 2.560 (s)
#Accuracy score: 0.8201284796573876

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
from sklearn.metrics import accuracy_score

# 从 Epochs 对象中提取数据
X_train_tensor = torch.Tensor(epochs_train.get_data())  # 假设 epochs_train 是 MNE Epochs 对象
y_train_tensor = torch.LongTensor(epochs_train.events[:, 2])
X_test_tensor = torch.Tensor(epochs_test.get_data())    # 假设 epochs_test 是 MNE Epochs 对象
y_test_tensor = torch.LongTensor(epochs_test.events[:, 2])

# 创建数据加载器
train_dataset = TensorDataset(X_train_tensor, y_train_tensor)
train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)

# 定义神经网络模型
class EEGClassifier(nn.Module):
    def __init__(self, input_size, num_classes):
        super(EEGClassifier, self).__init__()
        self.lstm = nn.LSTM(input_size, 256, batch_first=True)
        self.dropout = nn.Dropout(0.5)  # 添加 dropout 层
        self.fc = nn.Linear(256, num_classes)
    
    def forward(self, x):
        out, _ = self.lstm(x)
        out = self.dropout(out)  # 在 LSTM 层输出之后应用 dropout
        out = self.fc(out[:, -1, :])  # 获取最后一个时间步的输出
        return out


# 实例化模型
hidden_size1 = 200  # 第一个隐藏层大小
hidden_size2 = 100  # 第二个隐藏层大小
output_size = len(set(y_train_tensor.numpy()))  # 输出大小，类别数量
# 计算特征数
num_samples, num_channels, num_times = epochs_train.get_data().shape
num_features = num_channels * num_times

# 实例化神经网络模型
model = EEGClassifier(3000, output_size)

# 定义损失函数和优化器
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 训练模型
# 将标签值减去 1
y_train_tensor -= 1
y_test_tensor -= 1

num_epochs = 10
for epoch in range(num_epochs):
    for inputs, labels in train_loader:
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()

# 测试模型
with torch.no_grad():
    outputs = model(X_test_tensor)
    _, predicted = torch.max(outputs, 1)
    acc = accuracy_score(y_test_tensor.numpy(), predicted.numpy())

print("准确率: {}".format(acc))
qq_45779564
关注
三、机器学习基础知识：Python常用机器学习库（中文文本分析相关库）
weixin_42051846的博客
11-13 457
详细介绍了Python常用机器学习库里的中文文本分析相关库，主要包括Jieba和WordCloud两种库的参数和使用方式，同时结合实例介绍了这两种库的实际应用。
深度学习并不是在“模拟人脑”--周志华
蓁蓁尔的博客
01-01 6063
2016年12月18日，KDD China技术峰会在深圳举行，周志华教授当天做报告《关于机器学习研究的讨论》。详细见：http://mp.weixin.qq.com/s/5YZi2NONhLT5F5Hhbk5psg 下面是自己理解了的部分，如果文章中有错误，please have no hesitate to tall me， 感谢！ 1. 机器学习不是万能的（1）特征信息不充分：例如重要特征数据
机器学习之情感分析
weixin_47463127的博客
02-13 3193
文本情感分析步骤： 1.数据的爬取： 通过开发者工具来进行抓包，获取真实网址，然后利用爬虫技术对网页进行数据爬取。 import requests import json import csv class comments_spider(object): def __init__(self,filename='y'): self.header = { "User-Agent": "Mozilla / 5.0(Windows NT 10.0;Win64;x64
机器学习_基本python类型、判断与循环流程等
qq_37791134的博客
08-30 229
记录些冷门的东西，或许哪天就有用呢。或许是你很熟悉的东西，但是我不知道，所以好记性不如烂笔头呀 不在函数里时，globals（） = locals() teacher_name ='david' 和 globals()['teacher'] = 'david' 效果是一样的 ...
脑机接口基础学习06---机器学习算法随机森林判断睡眠类型
duohuanxi的博客
10-22 1140
案例介绍 本案例对多导睡眠图（Polysomnography，PSG）数据进行睡眠阶段的分类来判断睡眠类型 训练：对Alice的睡眠数据进行训练 测试：利用训练结果对Bob的睡眠数据进行测试，判断其睡眠类型 在分析之前，先简单介绍一下多导睡眠图，多导睡眠图（Polysomnography，PSG）又称睡眠脑电图。主要用于睡眠和梦境研究以及抑郁症和呼吸暂停综合征的诊断 多导睡眠图是通过不同部位的生物电或通过不同传感获得生物讯号，经前置放大，输出为不同的电讯号，记录出不同的图形以供分析。 数据集介绍： 本案例用
神经科学/机器学习：睡眠公开数据库
Rose9614的博客
08-08 1252
笔者自己整理的睡眠神经影像相关的公开数据库，可以用来进行机器学习或者神经影像的研究。目录睡眠剥夺健康人群年轻成年健康人群健康人群儿童OSA（阻塞性睡眠障碍）患者怀孕第36周妇女大学生认知障碍（AD,dementia,adhd…）老年人群嗜睡症与健康人群骨质疏松老年人群亚临床心血管疾病人群被试样本量数据机构链接备注。
基于电商产品评论数据情感分析
Abandon145的博客
05-27 2743
#!/usr/bin/env python # coding: utf-8 # # —— 基于电商产品评论数据情感分析 —— # ### 1.案例简介 # # 1、利用文本挖掘技术，对碎片化、非结构化的电商网站评论数据进行清洗与处理，转化为结构化数据。 # 2、参考知网发布的情感分析用词语集，统计评论数据的正负情感指数，然后进行情感分析,通过词云图直观查看正负评论的关键词。 # 3、比较“机器挖掘的正负情感”与“人工打标签的正负情感”，精度达到88%。 # 4、采.
HMM模型
weixin_43764703的博客
07-26 150
隐马尔可夫模型
python机器学习库教程——结巴中文分词
热门推荐
全栈工程师开发手册（原创）https://github.com/tencentmusic/cube-studio
12-09 1万+
全栈工程师开发手册 （作者：栾鹏） python教程全解 结巴中文分词安装：pip install jieba特点：支持三种分词模式：精确模式，试图将句子最精确地切开，适合文本分析； 全模式，把句子中所有的可以成词的词语都扫描出来, 速度非常快，但是不能解决歧义； 搜索引擎模式，在精确模式的基础上，对长词再次切分，提高召回率，适合用于搜索引擎分词。 支持繁体分词 支持自定义词典
JAK1抑制剂的机器学习方法
生命科学中的人工智能2（2022）100039研究文章JAK1抑制剂的分类和SAR研究的机器学习方法杨振武1人，田玉佳1人，孔跃3人，朱玉山2人，艾夏燕1人，1.化学资源工程国家重点实验室，制药工程系，P.O. 地址：北京市北三环...
感谢微信公众号 脑机接口社区文章《脑电分析系列[MNE-Python-5]| Python机器学习算法随机森林判断睡眠类型》之pycharm和anaconda对比，并记录其中遇到的问题
weixin_51735114的博客
11-16 1770
感谢微信公众号 脑机接口社区文章《脑电分析系列[MNE-Python-5]| Python机器学习算法随机森林判断睡眠类型》之pycharm和anaconda对比，并记录其中遇到的问题，欢迎各位大佬一起探讨研究！ Env—— Anaconda3：内置python3.8.12 Pycharm 使用本地python3.8.0 1. Pycharm 源码使用《脑机接口社区文章《脑电分析系列[MNE-Python-5]| Python机器学习算法随机森林判断睡眠类型》源码，如下—— """ 脑电分析系列[MNE-P
"PSG：对等语义网格框架体系结构
EgyptianInformatics Journal（2011）12，125开罗大学埃及信息学杂志www.elsevier.com/locate/eijwww.sciencedirect.com原创文章PSG：对等语义网格框架体系结构Amira Solimana，*， Amr Kamelb， Walaa Shetaa， ...
2.1 机器学习--KNN算法（分类）
我是个好人呀，????
10-15 1079
本章节我们来学习一种分类算法，KNN（K- Nearest Neighbor）法，即 K 最邻近法，最初由 Cover 和 Hart 于1968年提出，是一个理论上比较成熟的方法，也是最简单的机器学习算法之一。定义：如果一个样本在特征空间中的k 个最相似（即特征空间中最邻近的样本中的大多数属于某一个类别），则该样本也属于这个类别。我们该怎么理解呢？KNN 的原理就是当预测一个新的值 x 的时候，根据它距离最近的K个点是什么类别来判断x属于哪个类别。听起来有点绕，我们还是看看图吧。
机器学习：知识蒸馏（Knowledge Distillation，KD）
最新发布
2406_83947720的博客
10-15 1689
知识蒸馏最初由Hinton等人提出，目的是解决大型模型在部署时的资源消耗问题。其基本思想是通过让一个较小的模型学习较大模型的预测分布来获得类似的表现。教师模型（Teacher Model）：通常是一个大规模的、经过充分训练的模型，拥有复杂的结构和较高的准确率。学生模型（Student Model）：一个结构相对简单、参数较少的小型模型，蒸馏过程就是让该模型模仿教师模型的输出。知识蒸馏是一种有效的模型压缩技术，通过优化温度参数、损失函数权重、中间层特征对齐、数据增强等多种手段，可以显著提高学生模型的性能。
机器学习篇-day06-集成学习-随机森林 Adaboost GBDT XGBoost
m0_60916732的博客
10-12 1427
多个弱学习器组合成一个更强大的学习器，解决单一预测，进步一得到更好性能。# 导包​from sklearn.ensemble import RandomForestClassifier # 随即森丽分类​​# 定义随机森立函数# 数据读取# 数据基本处理# 确定特征和标签# print(x)# print(y)# 空值处理(填充)print(x)​# 处理字符类型 数据​# 数据划分x, y,stratify=y​# 模型训练# 决策树模型​。
机器学习_使用逻辑回归进行良/恶性乳腺癌肿瘤预测(附数据集下载链接, 长期有效)
JR521314的博客
10-15 620
关于代码中导入的模块, 个人更建议把导入的各个模块放在代码最前面, 有利于后期封装函数当然, 对于新手来说, 我的建议是模块在使用的时候导入, 这样学习的印象更深刻,等到知识和代码都熟练了, 再改也不迟 为了防止失效, 我就多放几个地址, 理解万岁,第一个直接去官网下载数据集, 第二个是我通过百度网盘分享的链接地址1:Breast Cancer Wisconsin (Original) - UCI Machine Learning Repositoryhttps://archive.ics.uci.ed
【机器学习】朴素贝叶斯算法|商品评论情感分析案例介绍及代码实现
weixin_57336987的博客
10-14 894
朴素贝叶斯算法-利用概率值进行分类的一种机器学习算法
人工智能AI与机器学习ML基础入门
JellyAI的博客
10-15 666
本人工智能学习课程连载的目标是帮助程序员理清思路，带你一步步通过写代码实现机器学习和深度学习的核心概念，构建像人类一样思考的模型，比如在计算机视觉、自然语言处理（NLP）等场景下应用。我们会先讲讲什么是传统编程，接着看看它的局限性，最后再看机器学习是如何解决这些问题的，同时开启了更多实现人工智能的机会。能够检测我们日常活动的健身追踪器是最近的创新，这不仅是因为有了便宜的小型硬件，还因为以前的算法根本无法实现这种检测。正如你所看到的，规则是用编程语言来表示的，这些规则作用于数据，最终得出结果。
R语言对矩阵的列进行标准化处理｜解锁数据分析中的核心步骤｜如何提升机器学习模型的表现？｜机器学习｜标准化｜数据处理｜R语言｜矩阵...
Java_fenxiang的博客
10-14 934
标准化是数据分析与机器学习中的重要步骤，尤其是在处理不同量纲的特征时，标准化有助于消除不同尺度带来的影响，使得算法在处理数据时更加高效且稳定。在R语言中，对矩阵的列进行标准化处理是一个常见的需求，本文将深入探讨如何使用R语言对矩阵数据的列进行标准化处理，并展示多种不同的标准化方法，如 Z-score 标准化、Min-Max...
斐讯PSG1208 K1无需拆机教程：刷Openwrt及固件升级
本文档主要介绍了如何在斐讯PSG1208 K1路由器上进行不拆机刷入Openwrt的操作流程，适用于希望通过该方法对路由器进行自定义固件升级的用户。以下是详细步骤： 1. **登录路由器**: 首先，通过浏览器访问路由器的默认...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值