Quick Start

Create a new post

$ hexo new "My New Post"

More info: Writing

Run server

$ hexo server

More info: Server

Generate static files

$ hexo generate

More info: Generating

Deploy to remote sites

$ hexo deploy

More info: Deployment

WinLibs - GCC+MinGW-w64 compiler for Windows下载你需要的版本
解压到D:\ProgramModule，并将 bin\加入环境变量PATH
打开新的Terminal输入gcc -v，查看gcc是否安装成功
在VS code 的插件管理下载Code Runner、C\C++这两个插件
在*.c源文件的内容区，右键点击Run Code ，即可运行成功

数据类型

• 整数类型

  short a = 12;     int b = 100;     long c = 1000L;     long long d = 1000000LL;     unsigned int e = 10;     printf("a: %hd\n",a);     printf("b: %d\n",b);     printf("c: %ld\n",c);     printf("d: %lld\n",d);     printf("e: %u\n",e);     printf("f: %.3f\n",f);

• 小数类型

  float f = 3.14F; printf("f: %.3f\n",f); double g = 5.65; printf("g: %.2lf\n",g);

• 字符类型

  char h = 'x'; printf("x: %c\n",x);

类型转换

• 隐式转换
• 强制转换

  int b = 23; short c = (short) b;

数组

#include <stdio.h>

int main(){
    int arr [10] = {2,3,4,5,6,7,8,9,10,11};
    arr[0] = 1525;
    *(arr+1) = 25;
    int len = sizeof(arr)/sizeof(arr[0]);
    void printArr(int arr[], int len){
        for (int i = 0; i < len;i++){
            printf("%d\t",arr[i]);
        }
    }
    printArr(arr,len);
    return 0;
}

指针

// swap the value of a and b
    void swap(int* x, int* y){
        int temp = *x;
        *x = *y;
        *y = temp;

    }
    int a = 5;
    int b = 10;
    swap(&a, &b);
    printf("a = %d b = %d\n", a, b);

#!/bin/bash

# 定义颜色
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[0;33m'
BLUE='\033[0;34m'
NC='\033[0m' # 无颜色

while true; do
    # 获取所有进程的CPU使用率和内存使用率
    cpu_usage=$(ps aux | awk '{sum_cpu += $3} END {print sum_cpu}')
    mem_usage=$(ps aux | awk '{sum_mem += $4} END {print sum_mem}')
    
    # 打印结果，带有时间戳、分隔线和颜色高亮
    echo -e "${BLUE}==============================${NC}"
    echo -e "${YELLOW}Timestamp: $(date)${NC}"
    echo -e "${BLUE}==============================${NC}"
    echo -e "${GREEN}Total CPU usage: ${RED}$cpu_usage%${NC}"
    echo -e "${GREEN}Total Memory usage: ${RED}$mem_usage%${NC}"
    echo -e "${BLUE}==============================${NC}"
    
    # 等待5秒后再次执行
    sleep 5
done

保存脚本到/usr/local/bin目录下

mv usage.sh /usr/local/bin/usage

Shell脚本编写的基本信息

#! /bin/bash
# -------------------------------------------------
# Filename:     test.sh
# Version:      1.0
# Date:         2024/05/02
# Author:       shenjianZ
# Email:        shenjianZLT@gmail.com
# Website:      https://blog.shenjianl.cn
# Description:  this is a test shell
# CopyRight:    2024 All rights reserved shenjianZ
# License       GPL
# ------------------------------------------------


# Your script logic goes here

随机森林

Random-Forest 就是Bagging + Decisiontree

import seaborn as sns
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split,GridSearchCV
from sklearn.feature_extraction import DictVectorizer
from sklearn.ensemble import RandomForestClassifier
# 1.获取数据集 - 加载 Titanic 数据集
titanic = sns.load_dataset('titanic')
missing_age_count = titanic['age'].isna().sum()
# print(f"缺失的 age 数量: {missing_age_count}")
# 2. 数据基本处理
# 2.1 确认特征值、目标值
X = titanic[['pclass','age','sex']]
y = titanic['survived']
# 2.2 缺失值处理
X.loc[:, 'age'] = X['age'].fillna(value=X['age'].mean())  # 使用 .loc 进行修改
# 2.3 划分数据集
X_train,X_test,y_train,y_test = train_test_split(X,y,random_state=22)
# 3. 特征工程（字典特征提取）
X_train = X_train.to_dict(orient="records")
X_test= X_test.to_dict(orient="records")
transfer = DictVectorizer()
X_train = transfer.fit_transform(X_train)
X_test = transfer.transform(X_test)
# 4. 机器学习 随机森林
rf = RandomForestClassifier()
gc = GridSearchCV(estimator=rf ,param_grid={"n_estimators":[100,120,300],"max_depth":[3,7,11]},cv=3)
gc.fit(X_train,y_train)
y_pred = gc.predict(X_test)
print(f"模型的测试集的预测值：{y_pred}")
ret = gc.score(X_test,y_test)
print(f"最佳模型在测试集上的评分:{ret}")
print(f"最佳模型的参数：{gc.best_estimator_}")
print(f"最佳模型在训练集上的评分：{gc.best_score_}")
print(X_test.toarray())

ott案例

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from imblearn.under_sampling import RandomUnderSampler
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import log_loss
from sklearn.preprocessing import OneHotEncoder
# 1. 获取数据集
data = pd.read_csv('./data/train.csv')
# 查看目标值分类
import seaborn as sns
sns.countplot(data=data, x='target', hue='target', palette="Set2", legend=False)  # 使用 hue='target' 替代 palette
plt.show()

# 2. 数据集的基本处理
# 2.1 确定特征值、目标值
x = data.drop(["id", "target"], axis=1)
y = data['target']

# 2.2 使用随机欠采样进行平衡
undersampler = RandomUnderSampler(sampling_strategy='auto', random_state=0)
x_resampled, y_resampled = undersampler.fit_resample(x, y)

# 查看欠采样后的类别分布
# print(f"欠采样后训练集中的类别分布：\n{y_train_resampled.value_counts()}")

# 2.3. 将标签转换为数字
le = LabelEncoder()
y_resampled = le.fit_transform(y_resampled)

# 2.4. 划分训练集和测试集
x_train, x_test, y_train, y_test = train_test_split(x_resampled, y_resampled, test_size=0.2)

 # 3. 机器学习
rf = RandomForestClassifier(oob_score = True)
rf.fit(x_train,y_train)
y_pred = rf.predict(x_test)
print(f"预测值:{y_pred}")
print(f"评分：{rf.score(x_test,y_test)}")

# # 4. 模型评估 （解决二分类预测问题）
# import numpy as np
# from sklearn.metrics import log_loss
# # 假设 y_pred_prob 是通过 predict_proba 得到的预测概率
# # 对预测概率进行裁剪，将其限制在 [eps, 1-eps] 范围内
# eps = 1e-15  # 设置一个小的eps值，避免极端值
# y_pred_prob = rf.predict_proba(x_test)
# y_pred_prob = np.clip(y_pred_prob, eps, 1 - eps)

# # 计算 log_loss
# loss = log_loss(y_test, y_pred_prob, normalize=True)
# print(f"Log Loss: {loss}")

# 4. 模型评估 （解决多分类预测问题）

# 获取预测的概率
y_pred_prob = rf.predict_proba(x_test)

# 使用 OneHotEncoder 对 y_test 进行 One-Hot 编码
encoder = OneHotEncoder(sparse_output=False)  # 确保返回的是密集矩阵
y_test_one_hot = encoder.fit_transform(y_test.reshape(-1, 1))

# 对预测概率进行裁剪，将其限制在 [eps, 1-eps] 范围内
eps = 1e-15
y_pred_prob = np.clip(y_pred_prob, eps, 1 - eps)

# 计算 log_loss
loss = log_loss(y_test_one_hot, y_pred_prob, normalize=True)
print(f"Log Loss: {loss}")

将当前样本的类别归类于距离最近的k个样本的类别

距离公式(2维)

• 欧式距离
  $$
  d = \sqrt{(x_1-y_1)^2 + (x_2 - y_2)^2}
  $$
• 曼哈顿距离
  $$
  d = |x_1 - x_2| + |y_1 - y_2|
  $$
• 切比雪夫距离
  $$
  d = \max\left(|x_1 - x_2|, |y_1 - y_2|\right)
  $$

k值选择问题

特征预处理

通过一些转换函数将特征数据转换成更加适合算法模型的特征数据过程

• 归一化
  将数据变换到指定区间（默认是[0,1]）
  $$ x’ = \frac{x- x_{\text {min}}}{x_{\text{max}} - x_{\text{min}}} $$
  若需要缩放到任意区间 ([a, b])，公式为： $$ x’ = a + \frac{(x - x_{\text{min}}) \cdot (b - a)}{x_{\text{max}} - x_{\text{min}}} $$
  其中：( [a, b] )：目标区间的范围
  归一化受到数据集的异常值的影响，需要进行标准化处理（更加合理）

  from sklearn.preprocessing import MinMaxScaler # 归一化

• 标准化
  将数据调整为均值为 0，标准差为 1 的标准正态分布
  $$ z = \frac{x - \mu}{\sigma} $$
  ( z )：标准化后的值 ( x )：原始数据值 ( $\mu$ )：数据的均值 ( $\sigma$)：数据的标准差

  from sklearn.preprocessing import StandardScaler # 标准化

KNN代码实现

import seaborn as sns
import matplotlib.pyplot as plt  
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.datasets import load_iris
from sklearn.preprocessing import MinMaxScaler,StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# 1 数据集获取
iris = load_iris()
# print(iris.feature_names)
iris_data = pd.DataFrame(iris.data,columns=['Sepal_Length', 'Sepal_Width', 'Petal_Length', 'Petal_Width'])
iris_data['target'] = iris.target

def iris_plot(data,col1,col2):
    sns.lmplot(x=col1,y=col2,data=data,hue="target",fit_reg=False)
    plt.show()
# 2 数据集可视化
# iris_plot(iris_data, 'Sepal_Width', 'Petal_Length')

# 3 数据集的划分
X_train,X_test,y_train,y_test = train_test_split(iris.data,iris.target,test_size=0.2,random_state=44)
# print("训练集的特征值：\n",X_train)
# print("训练集的目标值：\n",y_train)
# print("测试集的特征值：\n",X_test)
# print("测试集的特征值：\n",y_test)

# 4 归一化
transfer = StandardScaler()
X_train = transfer.fit_transform(X_train)
X_test = transfer.transform(X_test)
# print("归一化的,X_train：\n",X_train)
# print("归一化的X_test：\n",X_test)

# 5 机器学习 KNN
# 5.1 实例化估计器
estimator = KNeighborsClassifier(n_neighbors=9)
# 5.2 进行训练
estimator.fit(X_train,y_train)

# 6 模型评估
y_pred = estimator.predict(X_test)
print("预测值：\n",y_pre)
print("预测值与真实值是否相等：\n",y_pred==y_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"\nKNN 模型的准确率: {accuracy:.4f}")

交叉验证与网格搜索

import seaborn as sns
import matplotlib.pyplot as plt  
import pandas as pd
from sklearn.model_selection import train_test_split,GridSearchCV
from sklearn.datasets import load_iris
from sklearn.preprocessing import MinMaxScaler,StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# 1 数据集获取
iris = load_iris()
iris_data = pd.DataFrame(iris.data,columns=['Sepal_Length', 'Sepal_Width', 'Petal_Length', 'Petal_Width'])
iris_data['target'] = iris.target

# 3 数据集的划分
X_train,X_test,y_train,y_test = train_test_split(iris.data,iris.target,test_size=0.2)

# 4 归一化
transfer = StandardScaler()
X_train = transfer.fit_transform(X_train)
X_test = transfer.transform(X_test)

# 5 机器学习 KNN
# 5.1 实例化估计器
#
#不指定 <code> n_neighbors </code> ,使用网格搜索进行循环训练
estimator = KNeighborsClassifier()
# 5.2 模型调优 -- 交叉验证，网格搜素
estimator = GridSearchCV(estimator,param_grid={"n_neighbors":[1,3,5,7]},cv=5) # 5 折
# 5.2 进行训练
estimator.fit(X_train,y_train)
 
# 6 模型评估
y_pred = estimator.predict(X_test)
print("预测值：\n",y_pred)
print("预测值与真实值是否相等：\n",y_pred==y_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"\nKNN 模型的准确率: {accuracy:.4f}")

# 交叉验证的相关参数
print(f"最好结果：{estimator.best_score_}")
print(f"最好模型：{estimator.best_estimator_}")
print(f"最好模型结果：{estimator.cv_results_}")

机器学习的基本步骤

• 获取数据集
• 数据集基本处理
  • 去重去空、填充等操作
  • 确定特征值和目标值
  • 分割数据集
• 特征工程（特征预处理 标准化等）
• 机器学习
• 模型评估

数据分割的方法

• 留出法
  训练/测试集的划分要尽可能保持数据分布的一致性，避免因数据划分过程引入额外的偏差而对最终结果产生影响。
  单次使用留出法得到的估计结果往往不够稳定可靠，在使用留出法时，一般要采用若干次随机划分、重复进行实验评估后取平均值作为留出法的评估结果。

  from sklearn.model_selection import KFold,StratifiedKFold import pandas as pd X = np.array([ [1,2,3,4], [11,12,13,14], [21,22,23,24], [31,32,33,34], [41,42,43,44], [51,52,53,54], [61,62,63,64], [71,72,73,74] ]) y=np.array([1,1,0,0,1,1,0,0]) folder = KFold(n_splits=4) sfloder = StratifiedKFold(n_splits=4) print("KFOLD:") for train,test in folder.split(X,y): print(f"train:{train},test:{test}") print("SKFOLD:") for train,test in sfloder.split(X,y): print(f"train:{train},test:{test}")

  
• 自助法
• 交叉验证法

C4.5 是一种用于生成决策树的算法，不再使用信息增益，而是使用信息增益比，来避免偏向于选择取值较多的特征。信息增益比是信息增益与特征的熵的比值。

ID3

D3 是一种基于信息增益（Information Gain）的决策树算法

Cart

CART（分类与回归树）一种决策树算法，，CART 使用 二叉树结构，即每个节点只能有两个子节点。

cart剪枝

CART 决策树的剪枝方法分为 预剪枝（Pre-pruning）和 后剪枝（Post-pruning）两种：

预剪枝：

预剪枝是在构建决策树时就决定是否停止进一步划分某个节点。主要通过以下标准来控制：

• 当某个节点的样本数小于某个阈值时，不再继续划分。
• 当某个节点的 Gini 不纯度小于某个阈值时，不再继续划分。
  预剪枝的优点是能够减少计算量，但缺点是可能会导致模型不够复杂，从而产生欠拟合。

后剪枝：

后剪枝是在决策树完全构建出来之后，对树进行修剪。具体过程如下：

• 构建完整的决策树。
• 从叶子节点开始，逐渐向上遍历树的每个节点。
• 对每个节点进行判断，是否合适剪去该节点及其子树。如果剪去该子树后，模型的性能没有显著下降，就可以剪枝。
  后剪枝通过避免过度拟合来提高模型的泛化能力，但其计算开销较大。

特征工程(特征提取)

• 字典特征提取
  主要用于处理包含键值对（key-value pairs）的数据结构
     

  from sklearn.feature_extraction import DictVectorizer    # 字典特征提取    data = [        {'city': 'beijing', 'temperature': 100},        {'city': 'shanghai', 'temperature': 95},        {'city': 'guangzhou', 'temperature': 98}    ]    transfer = DictVectorizer(sparse=False)    new_data = transfer.fit_transform(data)    print(transfer.feature_names_)    print(new_data)

• 文本特征提取
  主要用于将文本数据（如句子、段落、文章等）转换成数值型特征。这对于文本分类、信息检索等任务非常重要。
     

  from sklearn.feature_extraction.text import CountVectorizer    # 示例文本数据    data = [        "I love programming",        "Python is great",        "I love machine learning"    ]    # 创建 CountVectorizer 对象    transfer = CountVectorizer()    # 将文本数据转换为特征向量    new_data = transfer.fit_transform(data)    # 输出特征名称    print("Feature Names:", transfer.get_feature_names_out())    # 输出转换后的特征矩阵    print("Transformed Data:", new_data.toarray())

• 文本特征提取（中文文本)

  from sklearn.feature_extraction.text import CountVectorizer   import jieba   # 中文文本数据（大于20个字）   data = [     "我热爱编程，学习编程语言是一件非常有趣的事情，它能够提升我们解决问题的能力，编程让我变得更加有创意。",     "Python语言是一门非常强大的编程语言，具有简洁的语法和丰富的库，可以帮助开发者更高效地完成任务。",     "机器学习是一项非常有前途的技术，它能够让计算机从数据中自动学习，逐步提高模型的精确度，解决实际问题。"   ]   # 使用jieba分词   text_list = []   for line in data:     text_list.append(" ".join(list(jieba.cut(line))))   # 创建 CountVectorizer 对象   transfer = CountVectorizer()   # 将文本数据转换为特征向量   new_data = transfer.fit_transform(text_list)   # 输出特征名称   print("Feature Names:", transfer.get_feature_names_out())   # 输出转换后的特征矩阵   print("Transformed Data:", new_data.toarray())

tf-idf

词频 * 逆文档频率

# tfi-df
from sklearn.feature_extraction.text import TfidfVectorizer
import jieba
data=["一种还是一种今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。",
      "我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去",
      "如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系"]
list = []
for item in data:
    list.append(" ".join(jieba.cut(item)))
transfer = TfidfVectorizer()
new_data = transfer.fit_transform(list)
print(f"特征名字：\n{transfer.get_feature_names_out()}")

print(f"转换后的特征矩阵:\n{ new_data.toarray()}")
print(f"转换后的数据:\n{new_data}")

回归决策树

决策树算法的应用 （泰坦尼克号沉船幸存者预测）

import seaborn as sns
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.feature_extraction import DictVectorizer
from sklearn.tree import DecisionTreeClassifier,export_graphviz
# 1.获取数据集 - 加载 Titanic 数据集
titanic = sns.load_dataset('titanic')
missing_age_count = titanic['age'].isna().sum()
# print(f"缺失的 age 数量: {missing_age_count}")
# 2. 数据基本处理
# 2.1 确认特征值、目标值
X = titanic[['pclass','age','sex']]
y = titanic['survived']
# 2.2 缺失值处理
X.loc[:, 'age'] = X['age'].fillna(value=X['age'].mean())  # 使用 .loc 进行修改
# 2.3 划分数据集
X_train,X_test,y_train,y_test = train_test_split(X,y,random_state=22)
# 3. 特征工程（字典特征提取）
X_train = X_train.to_dict(orient="records")
X_test= X_test.to_dict(orient="records")
transfer = DictVectorizer()
X_train = transfer.fit_transform(X_train)
X_test = transfer.transform(X_test)
# 4. 机器学习 决策树算法
estimator = DecisionTreeClassifier(criterion="gini")
estimator.fit(X_train,y_train)
y_pred = estimator.predict(X_test)
print(f"模型的测试集的预测值：{y_pred}")
ret = estimator.score(X_test,y_test)
print(f"模型的评分:{ret}")
print(X_test.toarray())

生成对应的图

from sklearn.tree import export_graphviz
import graphviz  # 用于渲染图像

# 导出决策树的 Graphviz 表示
export_graphviz(estimator, out_file='./data/tree.dot', 
                 feature_names=transfer.get_feature_names_out())  # 特征名称
# 使用 graphviz 渲染 .dot 文件
with open('./data/tree.dot', 'r') as f:
    dot_graph = f.read()
# 渲染决策树
graph = graphviz.Source(dot_graph)

# 设置保存路径
output_path = './data/decision_tree'  # 自定义保存路径

# 保存图像到指定路径，格式可以是 .png, .pdf, .jpg 等
# graph.render(output_path, format='png')  # 保存为 .png 文件

# 显示图像
graph.view(output_path)  # 打开图像，path为保存路径，不需要加后缀

Webgraphviz，这个网站可以将tree.dot文件的内容生成对应的可视化树

回归决策树与线性回归的对比

import numpy as np
import matplotlib.pyplot as plt
from sklearn.linear_model import LinearRegression
from sklearn.tree import DecisionTreeRegressor
from matplotlib import rcParams

# 设置matplotlib使用的字体为SimHei（黑体）
rcParams['font.sans-serif'] = ['SimHei']  # 也可以使用 'Microsoft YaHei'
rcParams['axes.unicode_minus'] = False  # 正常显示负号
x = np.array(list(range(1,11))).reshape(-1,1)
y = ([5.56,5.70,5.91,6.40,6.80,7.05,8.90,8.70,9.00,9.05])

m1 = DecisionTreeRegressor(max_depth=1)
m2 = DecisionTreeRegressor(max_depth=3)
m3 = DecisionTreeRegressor()

# 模型训练
m1.fit(x,y)
m2.fit(x,y)
m3.fit(x,y)

# 模型预测
x_test = np.arange(0,10,0.01).reshape(-1,1)
y_1 = m1.predict(x_test)
y_2 = m2.predict(x_test)
y_3 = m3.predict(x_test)

# 结果展示
plt.figure(figsize=(10,6),dpi=100)
plt.scatter(x,y ,label = "data")
plt.plot(x_test,y_1,label = "max_depth=1")
plt.plot(x_test,y_2,label = "max_depth=3")
plt.plot(x_test,y_3,label = "linearregression")
plt.xlabel("数据")
plt.ylabel("预测值")
plt.legend()
plt.show()

import pandas as pd
import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
# 1. 加载乳腺癌数据集
data = load_breast_cancer()
# 2.1  数据集基本处理
df = pd.DataFrame(data.data, columns=data.feature_names)
df['target'] = data.target
for i in df.columns:
    # 检查列是否有缺失值
    if np.any(pd.isnull(df[i])):
        print(f"Filling missing values in column: {i}")
#2.2 确认特征值、目标值
X = df.iloc[:,0:df.shape[1] - 1]
y = df.loc[:,"target"]
# 2.3 分割数据
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.3)
# 显示前几行数据
df.head(1)

# 3. 特征工程 标准化
transfer = StandardScaler()
X_train = transfer.fit_transform(X_train)
X_test = transfer.transform(X_test)

# 4 机器学习 逻辑回归
estimator = LogisticRegression()
estimator.fit(X_train,y_train)

# 5. 模型评估
print(f"模型准确率：{estimator.score(X_test,y_test)}")
print(f"模型预测值为:\n{estimator.predict(X_test)}")

分类评估的参数

• 准确率
  准确率是所有预测正确的样本占总样本的比例
  $$Accuracy = \frac{TP+TN}{TP+FN+FP+TN}$$

• 精准率
  精准率（又称查准率）是指所有被预测为正类的样本中，真正为正类的比例
  $$Precision = \frac{TP}{TP+FP}$$

• 召回率
  召回率（又称查全率）是指所有实际为正类的样本中，被正确预测为正类的比例
  $$Recall = \frac{TP}{TP+FN}$$

• F1-score
  F1 值（F1 Score）是精准率和召回率的调和平均数，综合考虑了精准率和召回率的影响。
  $$ F1 = 2 \times \frac{\text{Precision} \times \text{Recall}}{\text{Precision} + \text{Recall}} $$

• roc曲线
  tpr、fpr来衡量不平衡的二分类问题

import pandas as pd
import numpy as np
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, roc_auc_score
# 1. 加载乳腺癌数据集
data = load_breast_cancer()
# 2.1  数据集基本处理
df = pd.DataFrame(data.data, columns=data.feature_names)
df['target'] = data.target
for i in df.columns:
    # 检查列是否有缺失值
    if np.any(pd.isnull(df[i])):
        print(f"Filling missing values in column: {i}")
# 2.2 确认特征值、目标值
X = df.iloc[:, 0:df.shape[1] - 1]
y = df.loc[:, "target"]
# 2.3 分割数据
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)
# 显示前几行数据
df.head(1)

# 3. 特征工程 标准化
transfer = StandardScaler()
X_train = transfer.fit_transform(X_train)
X_test = transfer.transform(X_test)

# 4 机器学习 逻辑回归
estimator = LogisticRegression()
estimator.fit(X_train, y_train)

# 5. 模型评估
print(f"模型准确率：{estimator.score(X_test, y_test)}")
y_pred = estimator.predict(X_test)
print(f"模型预测值为:\n{y_pred}")
# 5.1 精确率、召回率
ret = classification_report(y_test, y_pred, labels=[1, 0], target_names=["良性", "恶性"])
roc_score = roc_auc_score(y_test, y_pred)
print(f"准确率、召回率：{ret}")
print(f"roc_score:{roc_score}")

类别不平衡的处理

先准备类别不平衡的数据

from imblearn.over_sampling import RandomOverSampler,SMOTE
from imblearn.under_sampling import RandomUnderSampler
from sklearn.datasets import make_classification
import matplotlib.pyplot as plt
from collections import Counter

# 1.准备类别不平衡的数据
X, y = make_classification(
    n_samples=5000,
    n_features=2,
    n_informative=2,
    n_redundant=0,
    n_repeated=0,
    n_classes=3,
    n_clusters_per_class=1,
    weights=[0.01, 0.05, 0.94],
    random_state=0,
)
counter = Counter(y)
plt.scatter(X[:,0],X[:,1],c=y)
plt.show()

• 过采样
  增加训练集的少数的类别的样本，使得正反例样本数据接近
  • 随机过采样（RandomOverSampler)

    ros = RandomOverSampler() X_resampled,y_resampled = ros.fit_resample(X,y) print(Counter(y_resampled)) plt.scatter(X_resampled[:,0],X_resampled[:,1],c=y_resampled) plt.show()

    
  • SMOTE过采样（SMOTE）

    smote = SMOTE() X_resampled,y_resampled = smote.fit_resample(X,y) print(Counter(y_resampled)) plt.scatter(X_resampled[:,0],X_resampled[:,1],c=y_resampled) plt.show()

    
• 欠采样
  减少训练集的多数的类别的样本，使得正反例样本数据接近
  • 随机欠采样（RandomUnderSampler）

    rus = RandomUnderSampler(random_state=0) X_resampled,y_resampled = rus.fit_resample(X,y) print(Counter(y_resampled)) plt.scatter(X_resampled[:,0],X_resampled[:,1],c=y_resampled) plt.show()

    

用于预测一个连续的目标变量（因变量），与一个或多个特征（自变量）之间存在线性关系。

假设函数：
$$y = w_1x_1 + w_2x_2 + \cdot\cdot\cdot+w_nx_n$$

• $y$ 是目标变量（因变量），即我们希望预测的值。
• $x1​,x2​,…,xn$​ 是特征变量（自变量），即输入的值。

损失函数

为了找到最佳的线性模型，我们需要通过最小化损失函数来优化模型参数。在线性回归中，常用的损失函数是 均方误差（MSE）：
$$J(\theta) = \frac{1}{2N} \sum_{i=1}^{N} (y_i - f_\theta(x_i))^2$$

• N 是样本的数量。
• $y_i$​ 是第 i 个样本的真实值。
• $f_\theta(x_i)$ 是模型预测的第 i 个样本的值。

线性回归优化

• 梯度下降法

  from sklearn.datasets import fetch_california_housing from sklearn.model_selection import train_test_split from sklearn.preprocessing import StandardScaler from sklearn.linear_model import SGDRegressor from sklearn.metrics import mean_squared_error # 1. 获取数据集 housing = fetch_california_housing() # 2. 数据集处理 # 2.1 分割数据集 X_train, X_test, y_train, y_test = train_test_split(housing.data, housing.target, test_size=0.25) # 3. 特征工程 # 3.1 标准化 transfer = StandardScaler() X_train = transfer.fit_transform(X_train) X_test = transfer.transform(X_test) # 使用 transform() 而不是 fit_transform() # 4.机器学习- 梯度下降法 estimater = SGDRegressor(max_iter=1000, eta0=0.01) estimater.fit(X_train, y_train) print(f"SGD模型的偏置是：{estimater.intercept_}") print(f"SGD模型的系数是：{estimater.coef_}") # 5. 模型评估 y_pred = estimater.predict(X_test) print(f"SGD模型预测值：{y_pred}") mse = mean_squared_error(y_test, y_pred) print(f"SGD模型均方误差:{mse}")

• 正规方程

  from sklearn.datasets import fetch_california_housing from sklearn.model_selection import train_test_split from sklearn.preprocessing import StandardScaler from sklearn.linear_model import LinearRegression from sklearn.metrics import mean_squared_error # 1. 获取数据集 housing = fetch_california_housing() # 2. 数据集处理 # 2.1 分割数据集 X_train, X_test, y_train, y_test = train_test_split(housing.data, housing.target, test_size=0.25) # 3. 特征工程 # 3.1 标准化 transfer = StandardScaler() X_train = transfer.fit_transform(X_train) X_test = transfer.fit_transform(X_test) # 4.机器学习- 线性回归 estimater = LinearRegression() estimater.fit(X_train, y_train) print(f"模型的偏置是：{estimater.intercept_}") print(f"模型的系数是：{estimater.coef_}") # 5. 模型评估 y_pred = estimater.predict(X_test) print(f"模型预测值：{y_pred}") mse = mean_squared_error(y_test, y_pred) print(f"模型均方误差:{mse}")

• 岭回归

  from sklearn.datasets import fetch_california_housing from sklearn.model_selection import train_test_split from sklearn.preprocessing import StandardScaler from sklearn.linear_model import Ridge, RidgeCV from sklearn.metrics import mean_squared_error # 1. 获取数据集 housing = fetch_california_housing() # 2. 数据集处理 # 2.1 分割数据集 X_train, X_test, y_train, y_test = train_test_split(housing.data, housing.target, test_size=0.25) # 3. 特征工程 # 3.1 标准化 transfer = StandardScaler() X_train = transfer.fit_transform(X_train) X_test = transfer.transform(X_test) # 使用 transform() 而不是 fit_transform() # 4.机器学习- 岭回归 使用了Ridge的alpha的搜索 # estimater = Ridge(alpha=1.0) estimater = RidgeCV(alphas=[0.001, 0.01, 0.1, 1, 10, 100]) estimater.fit(X_train, y_train) print(f"Ridge模型的偏置是：{estimater.intercept_}") print(f"Ridge模型的系数是：{estimater.coef_}") # 查看最佳 alpha print(f"最佳 alpha 值是：{estimater.alpha_}") # 5. 模型评估 y_pred = estimater.predict(X_test) print(f"Ridge模型预测值：{y_pred}") mse = mean_squared_error(y_test, y_pred) print(f"Ridge模型均方误差:{mse}")

这样每个代码块的缩进保持一致，便于阅读和理解。如果有其他优化需求，随时告诉我！

模型保存和加载

from sklearn.datasets import fetch_california_housing
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import Ridge, RidgeCV
from sklearn.metrics import mean_squared_error
import joblib

def save_model():
    # 1. 获取数据集
    housing = fetch_california_housing()
    # 2. 数据集处理
    # 2.1 分割数据集
    X_train, X_test, y_train, y_test = train_test_split(housing.data, housing.target, test_size=0.25)
    # 3. 特征工程
    # 3.1 标准化
    transfer = StandardScaler()
    X_train = transfer.fit_transform(X_train)
    X_test = transfer.transform(X_test)  # 使用 transform() 而不是 fit_transform()
    # 4. 机器学习 - 岭回归 使用了Ridge的alpha的搜索
    estimater = RidgeCV(alphas=[0.001, 0.01, 0.1, 1, 10, 100])
    estimater.fit(X_train, y_train)
    print(f"Ridge模型的偏置是：{estimater.intercept_}")
    print(f"Ridge模型的系数是：{estimater.coef_}")
    # 保存模型
    joblib.dump(estimater, 'ridge_model.pkl')
    # 查看最佳 alpha
    print(f"最佳 alpha 值是：{estimater.alpha_}")
    # 5. 模型评估
    y_pred = estimater.predict(X_test)
    mse = mean_squared_error(y_test, y_pred)
    print(f"Ridge模型均方误差:{mse}")

def load_model():
    # 1. 获取数据集
    housing = fetch_california_housing()
    # 2. 数据集处理
    # 2.1 分割数据集
    X_train, X_test, y_train, y_test = train_test_split(housing.data, housing.target, test_size=0.25)
    # 3. 特征工程
    # 3.1 标准化
    transfer = StandardScaler()
    X_train = transfer.fit_transform(X_train)
    X_test = transfer.transform(X_test)  # 使用 transform() 而不是 fit_transform()
    # 加载模型
    estimater = joblib.load('ridge_model.pkl')
    print(f"Ridge模型的偏置是：{estimater.intercept_}")
    print(f"Ridge模型的系数是：{estimater.coef_}")
    # 查看最佳 alpha
    print(f"最佳 alpha 值是：{estimater.alpha_}")
    # 5. 模型评估
    y_pred = estimater.predict(X_test)
    mse = mean_squared_error(y_test, y_pred)
    print(f"Ridge模型预测值：{y_pred}")
    print(f"Ridge模型均方误差:{mse}")

print("训练并保存模型：")
save_model()
print("加载模型")
load_model()

      初，郑武公娶于申【申国】，曰武姜【武为武公谥号，姜为其宗族之性】。生庄公及共叔段【共表示其曾出逃到共，叔为老三，段为名】。庄公寤生【出生时头先出，难产】，惊姜氏，故名曰“寤生”， 遂恶之，爱【喜爱】共叔段，欲立【立为储君】之，亟（qì）【多次】请于武公，及庄公即位，为之【共叔段】请制【一个叫制的封地，虎牢关所在】。公曰：“制，岩邑【险要的城邑】也，虢叔死焉，佗【通“他”，其他】邑唯命（是听）。”请京，使居之，谓之“京城大叔”。

# 在 6 台主机执行
systemctl stop firewalld
systemctl disable firewalld

配置yum源

• 下载 repo 文件：
  Centos-7.repo
  并上传到/tmp，进入到/tmp
• 备份并且替换系统的repo文件

  cp Centos-7.repo /etc/yum.repos.d/ cd /etc/yum.repos.d/ mv CentOS-Base.repo CentOS-Base.repo.bak mv Centos-7.repo CentOS-Base.repo

• 将nn1上的CentOS-Base.repo拷贝到其他主机

  scp /etc/yum.repos.d/CentOS-Base.repo root@nn2:/etc/yum.repos.d scp /etc/yum.repos.d/CentOS-Base.repo root@nn3:/etc/yum.repos.d scp /etc/yum.repos.d/CentOS-Base.repo root@s1:/etc/yum.repos.d scp /etc/yum.repos.d/CentOS-Base.repo root@s2:/etc/yum.repos.d scp /etc/yum.repos.d/CentOS-Base.repo root@s3:/etc/yum.repos.d

• 执行yum源更新命令

  yum clean all yum makecache yum update -y

• 安装常用软件

  yum install -y openssh-server vim gcc gcc-c++ glibc-headers bzip2-devel lzo-devel curl wget openssh-clients zlib-devel autoconf automake cmake libtool openssl-devel fuse-devel snappy-devel telnet unzip zip net-tools.x86_64 firewalld systemd ntp unrar bzip2

JDK安装

注意需要在六台机器依次执行

• 上传到/tmp目录下，安装

  cd /tmp rpm -ivh jdk-8u144-linux-x64.rpm

• 配置环境变量

  ln -s /usr/java/jdk1.8.0_144/ /usr/java/jdk1.8 echo 'export JAVA_HOME=/usr/java/jdk1.8' >> /etc/profile.d/myEnv.sh echo 'export PATH=$PATH:$JAVA_HOME/bin' >> /etc/profile.d/myEnv.sh source /etc/profile java -version

修改主机名和主机名映射

vim /etc/hostname

6台机器分别为nn1、nn2、nn3、s1、s2、s3

vim /etc/hosts

修改为

192.168.1.30 nn1
192.168.1.31 nn2
192.168.1.32 nn3
192.168.1.33 s1
192.168.1.34 s2
192.168.1.35 s3

创建hadoop用户

#创建hadoop用户 
useradd hadoop 
#给hadoop用户设置密码: 12345678 
passwd hadoop

禁止非 wheel 组用户切换到root，配置免密切换root

• 修改/etc/pam.d/su配置

  sed -i 's/#auth\t\trequired\tpam_wheel.so/auth\t\trequired\tpam_wheel.so/g' '/etc/pam.d/su' sed -i 's/#auth\t\tsufficient\tpam_wheel.so/auth\t\tsufficient\tpam_wheel.so/g' '/etc/pam.d/su'

• 修改/etc/login.defs文件

  echo "SU_WHEEL_ONLY yes" >> /etc/login.defs

• 添加用户到管理员，禁止普通用户su 到 root

  #把hadoop用户加到wheel组里 gpasswd -a hadoop wheel #查看wheel组里是否有hadoop用户 cat /etc/group | grep wheel

给hadoop用户，配置SSH密钥

配置hadoop用户ssh免密码登录到hadoop

• 仅在nn1执行这段脚本命令即可
  但是 su - hadoop , mkdir ~/.ssh 需要在其他主机执行一下

  #切换到hadoop用户 su - hadoop #生成ssh公私钥 ssh-keygen -t rsa -f ~/.ssh/id_rsa -P '' ssh-copy-id nn1 ssh-copy-id nn2 ssh-copy-id nn3 ssh-copy-id s1 ssh-copy-id s2 ssh-copy-id s3 scp /home/hadoop/.ssh/id_rsa hadoop@nn2:/home/hadoop/.ssh scp /home/hadoop/.ssh/id_rsa hadoop@nn3:/home/hadoop/.ssh scp /home/hadoop/.ssh/id_rsa hadoop@s1:/home/hadoop/.ssh scp /home/hadoop/.ssh/id_rsa hadoop@s2:/home/hadoop/.ssh scp /home/hadoop/.ssh/id_rsa hadoop@s3:/home/hadoop/.ssh

配置hadoop用户ssh免密码登录到root

• 同上

  ssh-copy-id root@nn1 ssh-copy-id root@ nn2 ssh-copy-id root@nn3 ssh-copy-id root@s1 ssh-copy-id root@s2 ssh-copy-id root@s3 scp /home/hadoop/.ssh/id_rsa root@nn2:/root/.ssh scp /home/hadoop/.ssh/id_rsa root@nn3:/root/.ssh scp /home/hadoop/.ssh/id_rsa root@s1:/root/.ssh scp /home/hadoop/.ssh/id_rsa root@s2:/root/.ssh scp /home/hadoop/.ssh/id_rsa root@s3:/root/.ssh

脚本配置

• ips

  vim /home/hadoop/bin/ips

  nn1 nn2 nn3 s1 s2 s3

• ssh_all.sh

  vim /home/hadoop/bin/ssh_all.sh

  #! /bin/bash # 进入到当前脚本所在目录 cd `dirname $0` # 获取当前脚本所在目录 dir_path=`pwd` #echo $dir_path # 读ips文件得到数组(里面是一堆主机名) ip_arr=(`cat $dir_path/ips`) # 遍历数组里的主机名 for ip in ${ip_arr[*]} do # 拼接ssh命令: ssh hadoop@nn1.hadoop ls cmd_="ssh hadoop@${ip} \"$*\" " echo $cmd_ # 通过eval命令 执行 拼接的ssh 命令 if eval ${cmd_} ; then echo "OK" else echo "FAIL" fi done

• ssh_root.sh

  #! /bin/bash # 进入到当前脚本所在目录 cd `dirname $0` # 获取当前脚本所在目录 dir_path=`pwd` #echo $dir_path # 读ips文件得到数组(里面是一堆主机名) ip_arr=(`cat $dir_path/ips`) # 遍历数组里的主机名 for ip in ${ip_arr[*]} do # 拼接ssh命令: ssh hadoop@nn1.hadoop ls cmd_="ssh hadoop@${ip} ~/bin/exe.sh \"$*\"" echo $cmd_ # 通过eval命令 执行 拼接的ssh 命令 if eval ${cmd_} ; then echo "OK" else echo "FAIL" fi done

• scp_all.sh

  #! /bin/bash # 进入到当前脚本所在目录 cd `dirname $0` # 获取当前脚本所在目录 dir_path=`pwd` #echo $dir_path # 读ips文件得到数组(里面是一堆主机名) ip_arr=(`cat $dir_path/ips`) # 源 source_=$1 # 目标 target=$2 # 遍历数组里的主机名 for ip in ${ip_arr[*]} do # 拼接scp命令: scp 源 hadoop@nn1.hadoop:目标 cmd_="scp -r ${source_} hadoop@${ip}:${target}" echo $cmd_ # 通过eval命令 执行 拼接的scp 命令 if eval ${cmd_} ; then echo "OK" else echo "FAIL" fi done

• exe.sh

  #切换到root用户执行cmd命令 cmd=$* su - << EOF $cmd EOF

• 赋予执行权限

  chmod +x ssh_all.sh chmod +x scp_all.sh chmod +x ssh_root.sh chmod +x exe.sh

• 分发到其他主机

  ./ssh_all.sh mkdir /home/hadoop/bin ./scp_all.sh /home/hadoop/bin/ips /home/hadoop/bin/ ./scp_all.sh /home/hadoop/bin/exe.sh /home/hadoop/bin/ ./scp_all.sh /home/hadoop/bin/ssh_all.sh /home/hadoop/bin/ ./scp_all.sh /home/hadoop/bin/scp_all.sh /home/hadoop/bin/ ./scp_all.sh /home/hadoop/bin/ssh_root.sh /home/hadoop/bin/

• 将 /home/hadoop/bin添加到hadoop用户的环境变量，需要切换到hadoop用户

  echo 'export PATH=$PATH:/home/hadoop/bin' >> ~/.bashrc && source ~/.bashrc scp_all.sh /home/hadoop/.bashrc /home/hadoop/ ssh_all.sh source ~/.bashrc

注意在六台机器均上传到/tmp

# 在6台机器执行
sudo tar -zxvf /tmp/hadoop-3.1.4.tar.gz -C /usr/local/
# 分发到其他主机
ssh_root.sh chown -R hadoop:hadoop /usr/local/hadoop-3.1.4
ssh_root.sh ln -s /usr/local/hadoop-3.1.4/ /usr/local/hadoop

配置环境变量

echo 'export HADOOP_HOME=/usr/local/hadoop' >> /etc/profile.d/myEnv.sh
echo 'export PATH=$PATH:$HADOOP_HOME/bin' >> /etc/profile.d/myEnv.sh
echo 'export PATH=$PATH:$HADOOP_HOME/sbin' >> /etc/profile.d/myEnv.sh

# 分发到nn2、nn3、s1、s2、s3
scp_all.sh /etc/profile.d/myEnv.sh /etc/profile.d/
# source 环境变量
ssh_root.sh source /etc/profile

还需要创建 /data这个目录，由于nn1、nn2、nn3已经创建/data，其他三台需要创建一下

### 在s1、s2、s3执行
sudo mkdir /data
sudo chown -R hadoop:hadoop /data

修改core-site.xml

vim /usr/local/hadoop/etc/hadoop/core-site.xml 

<configuration>
	<property>
	    <name>fs.defaultFS</name>
	    <value>hdfs://ns1</value>
	    <description>默认文件服务的协议和NS逻辑名称，和hdfs-site.xml里的对应此配置替代了1.0里的fs.default.name</description>
	</property>
	
	<property>
	    <name>hadoop.tmp.dir</name>
	    <value>/data/tmp</value>
	    <description>数据存储目录</description>
	</property>
	
	<property>
	    <name>hadoop.proxyuser.root.groups</name>
	    <value>hadoop</value>
	    <description>
	        hdfs dfsadmin –refreshSuperUserGroupsConfiguration,
	        yarn rmadmin –refreshSuperUserGroupsConfiguration
	        使用这两个命令不用重启就能刷新
	    </description>
	</property>
	
	<property>
	    <name>hadoop.proxyuser.root.hosts</name>
	    <value>localhost</value>
	    <description>本地代理</description>
	</property>
	
	<!-- zkfc的配置 -->
	<property> 
		<name>ha.zookeeper.quorum</name> 
		<value>nn1:2181,nn2:2181,nn3:2181</value> 
		<description>HA使用的zookeeper地址</description> 
	</property>
</configuration>

修改hdfs-site.xml

vim /usr/local/hadoop/etc/hadoop/hdfs-site.xml 

<configuration>
    <property>
        <name>dfs.namenode.name.dir</name>
        <value>/data/namenode</value>
        <description>namenode本地文件存放地址</description>
    </property>
    
    <property>
        <name>dfs.nameservices</name>
        <value>ns1</value>
        <description>提供服务的NS逻辑名称，与core-site.xml里的对应</description>
    </property>
    
    <!-- namenode的配置 -->
    <!-- 主要的 -->
    <property>
        <name>dfs.ha.namenodes.ns1</name>
        <value>nn1,nn2,nn3</value>
        <description>列出该逻辑名称下的NameNode逻辑名称</description>
    </property>
    
    <property>
        <name>dfs.namenode.rpc-address.ns1.nn1</name>
        <value>nn1:9000</value>
        <description>指定NameNode的RPC位置</description>
    </property>
    
    <property>
        <name>dfs.namenode.http-address.ns1.nn1</name>
        <value>nn1:50070</value>
        <description>指定NameNode的Web Server位置</description>
    </property>
    
    <property>
        <name>dfs.namenode.rpc-address.ns1.nn2</name>
        <value>nn2:9000</value>
        <description>指定NameNode的RPC位置</description>
    </property>
    
    <property>
        <name>dfs.namenode.http-address.ns1.nn2</name>
        <value>nn2:50070</value>
        <description>指定NameNode的Web Server位置</description>
    </property>
    
    <property>
        <name>dfs.namenode.rpc-address.ns1.nn3</name>
        <value>nn3:9000</value>
        <description>指定NameNode的RPC位置</description>
    </property>
    
    <property>
        <name>dfs.namenode.http-address.ns1.nn3</name>
        <value>nn3:50070</value>
        <description>指定NameNode的Web Server位置</description>
    </property>
    
    <property>
        <name>dfs.namenode.handler.count</name>
        <value>77</value>
        <description>namenode的工作线程数</description>
    </property>

    <!-- journaldata配置,使得其他两个namenode同步第一个namenode数据 --> 
    <property>
        <name>dfs.namenode.shared.edits.dir</name>
        <value>qjournal://nn1:8485;nn2:8485;nn3:8485/ns1</value>
        <description>指定用于HA存放edits的共享存储，通常是namenode的所在机器</description>
    </property>
    
    <property>
        <name>dfs.journalnode.edits.dir</name>
        <value>/data/journaldata/</value>
        <description>journaldata服务存放文件的地址</description>
    </property>
    
    <property>
        <name>ipc.client.connect.max.retries</name>
        <value>10</value>
        <description>namenode和journalnode的链接重试次数10次</description>
    </property>
    
    <property>
        <name>ipc.client.connect.retry.interval</name>
        <value>10000</value>
        <description>重试的间隔时间10s</description>
    </property>

    <!-- zkfc的配置 -->
    <property>
        <name>dfs.ha.fencing.methods</name>
        <value>sshfence</value>
        <description>指定HA做隔离的方法，缺省是ssh，可设为shell，稍后详述</description>
    </property>
    
    <property>
        <name>dfs.ha.fencing.ssh.private-key-files</name>
        <value>/home/hadoop/.ssh/id_rsa</value>
        <description>杀死命令脚本的免密配置秘钥</description>
    </property>
    
    <property>
        <name>dfs.client.failover.proxy.provider.ns1</name>
        <value>org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider</value>
        <description>指定客户端用于HA切换的代理类，不同的NS可以用不同的代理类以上示例为Hadoop 2.0自带的缺省代理类</description>
    </property>
    
    <property>
        <name>dfs.client.failover.proxy.provider.auto-ha</name>
        <value>org.apache.hadoop.hdfs.server.namenode.ha.ConfiguredFailoverProxyProvider</value>
    </property> 
    
    <property>
        <name>dfs.ha.automatic-failover.enabled</name>
        <value>true</value>
    </property>
	<!-- datanode配置 -->
	<property>
	    <name>dfs.datanode.data.dir</name>
	    <value>/data/datanode</value>
	    <description>datanode本地文件存放地址</description>
	</property>
	<property>
	    <name>dfs.replication</name>
	    <value>3</value>
	    <description>文件复本数</description>
	</property>
	<property>
	    <name>dfs.namenode.datanode.registration.ip-hostname-check</name>
	    <value>false</value>
	</property>
	<property>
	    <name>dfs.client.use.datanode.hostname</name>
	    <value>true</value>
	</property>
	<property>
	    <name>dfs.datanode.use.datanode.hostname</name>
	    <value>true</value>
	</property>
</configuration>

修改hadoop-env.sh

vim /usr/local/hadoop/etc/hadoop/hadoop-env.sh

# 添加这两行
source /etc/profile 
export HADOOP_HEAPSIZE_MAX=512

分发这些配置文件

scp_all.sh /usr/local/hadoop/etc/hadoop/core-site.xml /usr/local/hadoop/etc/hadoop/
scp_all.sh /usr/local/hadoop/etc/hadoop/hdfs-site.xml /usr/local/hadoop/etc/hadoop/
scp_all.sh /usr/local/hadoop/etc/hadoop/hadoop-env.sh /usr/local/hadoop/etc/hadoop/

集群初始化

• 需要先启动zookeeper集群

  ssh_all_zookeeper.sh /usr/local/zookeeper/bin/zkServer.sh start

  # 第一次启动先启动journalnode，便于3个namenode的元数据同步 ssh_all_zookeeper.sh hadoop-daemon.sh start journalnode

• zkfc搭建

  #在nn1节点执行 hdfs zkfc -formatZK #nn1 nn2 nn3启动zkfc hadoop-daemon.sh start zkfc

• 初始化nn1的namenode，在nn1执行

  hdfs namenode -format hadoop-daemon.sh start namenode

• 格式化第二台和第三台namenode，并且启动namenode,在nn2、nn3执行

  hdfs namenode -bootstrapStandby hadoop-daemon.sh start namenode

• 修改workers

  vim /usr/local/hadoop/etc/hadoop/workers

  修改为

  s1 s2 s3

  分发给其他机器

  scp_all.sh /usr/local/hadoop/etc/hadoop/workers /usr/local/hadoop/etc/hadoop

• 启动datanode节点，在s1、s2、s3执行

  #启动各个节点的datanode hadoop-daemons.sh start datanode

集群启动

start-dfs.sh

自从docker官方仓库在中国大陆被墙后，docker的部署方式也发生了改变。
解决docker安装问题：https://github.com/shenjianZ/docker_installer

1. 安装docker

   sudo curl -fsSL https://gitee.com/tech-shrimp/docker_installer/releases/download/latest/linux.sh| bash -s docker --mirror Aliyun

2. 启动docker

   sudo systemctl start docker

3. 设置开机自启

   sudo systemctl enable docker

4. Docker pull images

   将image下载到阿里云镜像仓库中
   解决docker pull 镜像问题:https://github.com/shenjianZ/docker_image_pusher

   1. 登录阿里云镜像服务 https://cr.console.aliyun.com/,

      启用个人实例，创建一个命名空间（ALIYUN_NAME_SPACE）

   2. 在访问凭证 可以看到账号 用户名（ALIYUN_REGISTRY_USER)

      密码（ALIYUN_REGISTRY_PASSWORD)

      仓库地址（ALIYUN_REGISTRY）

   3. 启动Action
      进入您自己的项目，点击Action，启用Github Action功能

   4. 配置环境变量
      进入Settings->Secret and variables->Actions->New Repository secret
      将上一步的四个值
      ALIYUN_NAME_SPACE,

      ALIYUN_REGISTRY_USER，

      ALIYUN_REGISTRY_PASSWORD，

      ALIYUN_REGISTRY
      配置成环境变量

   5. 添加镜像
      打开images.txt文件，添加你想要的镜像 可以加tag

   6. 使用镜像
      回到阿里云，镜像仓库，点击任意镜像，可查看镜像状态。(可以改成公开，拉取镜像免登录)

"easycom":{
  "autoscan": true,
  "custom": {
    "^tui-(.*)": "@/components/thorui/tui-$1/tui-$1.vue"  // 匹配components目录内的vue文件
  }
}

tui-sticky 吸顶容器

包含 以下 tui 组件 :

• tui-sticky
• tui-list-view
• tui-list-cell

<tui-sticky :scrollTop="scrollTop" stickyHeight="104rpx" container>
    <!-- header start -->
    <template v-slot:header>
        <view class="sticky-item">
            <view class="setting">设置</view>
        </view>
    </template>
    <!-- header end -->
    <!--内容 start-->
    <template v-slot:content>
        <tui-list-view class="content">
            <tui-list-cell  :arrow="false">
                <switch class='switch' checked color="#FFCC33" />
            </tui-list-cell>
        </tui-list-view>
    </template>
    <!--内容 end-->
</tui-sticky>

<script setup>
    import { ref } from 'vue'
    import { onPageScroll } from '@dcloudio/uni-app'

    // 定义 scrollTop 响应式变量
    const scrollTop = ref(0)
    // 监听页面滚动事件
    onPageScroll((e) => {
        scrollTop.value = e.scrollTop
    })
</script>

• 拷贝ips

  cp ips ips_zookeeper

  修改为

  nn1 nn2 nn3

• 拷贝三个脚本

  cp scp_all.sh scp_all_zookeeper.sh cp ssh_all.sh ssh_all_zookeeper.sh cp ssh_root.sh ssh_root_zookeeper.sh

• 修改脚本

  vim scp_all_zookeeper.sh vim ssh_all_zookeeper.sh vim ssh_root_zookeeper.sh

  将三个脚本中的ips改为ips_zookeeper

Zookeeper安装

• 上传到/tmp目录下，解压

  sudo tar -zxvf /tmp/zookeeper-3.4.8.tar.gz -C /usr/local/ scp -r /usr/local/zookeeper-3.4.8/ root@nn2:/usr/local/ scp -r /usr/local/zookeeper-3.4.8/ root@nn3:/usr/local/ ssh_root_zookeeper.sh chown -R hadoop:hadoop /usr/local/zookeeper-3.4.8 ssh_root_zookeeper.s ln -s /usr/local/zookeeper-3.4.8/ /usr/local/zookeeper

Zookeeper配置

• zoo.cfg配置

  cd /usr/local/zookeeper/conf/ cp zoo_sample.cfg zoo.cfg

  然后vim zoo.cfg,修改如下：

  # 修改dataDir dataDir=/data/zookeeper # 添加一下内容 server.1=nn1:2888:3888 server.2=nn2:2888:3888 server.3=nn3:2888:3888

  分发给nn2、nn3
  scp_all_zookeeper.sh /usr/local/zookeeper/conf/zoo.cfg /usr/local/zookeeper/conf/

• zkEnv.sh配置
  vim /usr/local/zookeeper/bin/zkEnv.sh
  
  分发到nn2、nn3

  scp_all_zookeeper.sh /usr/local/zookeeper/bin/zkEnv.sh /usr/local/zookeeper/bin/

• 创建zookeeper数据目录

  ssh_root_zookeeper.sh mkdir -p /data/zookeeper ssh_root_zookeeper.sh chown -R hadoop:hadoop /data

• 创建myid文件

  ssh nn1 'echo "1" > /data/zookeeper/myid' ssh nn2 'echo "2" > /data/zookeeper/myid' ssh nn3 'echo "3" > /data/zookeeper/myid'

• 配置Zookeeper环境变量

  # 在其他所有主机也执行 sudo chown -R hadoop:hadoop /etc/profile.d/myEnv.sh

  echo 'export ZOOKEEPER_HOME=/usr/local/zookeeper' >> /etc/profile.d/myEnv.sh echo 'export PATH=$PATH:$ZOOKEEPER_HOME/bin' >> /etc/profile.d/myEnv.sh

  # 分发到nn2、nn3 scp_all_zookeeper.sh /etc/profile.d/myEnv.sh /etc/profile.d/ # source 环境变量 ssh_all_zookeeper.sh source /etc/profile

Zookeeper的命令

#启动zk服务
ssh_all_zookeeper.sh /usr/local/zookeeper/bin/zkServer.sh start
#查看每个机器ZK运行的状态
ssh_all_zookeeper.sh /usr/local/zookeeper/bin/zkServer.sh status
#整体停止服务
ssh_all_zookeeper.sh /usr/local/zookeeper/bin/zkServer.sh stop 
#重启zk服务
ssh_all_zookeeper.sh /usr/local/zookeeper/bin/zkServer.sh restart

#启动zookeeper客户端，并连接zookeeper集群
/usr/local/zookeeper/bin/zkCli.sh -server nn1:2181
# 可以简化为:
zkCli.sh

由于中国大陆的GFW（防火墙）限制，无法访问外网网络，因此需要访问像GitHub、YouTube这样的
的网站将被屏蔽拦截，接下来我将给出一种使用VPN服务的可行的方案来保证服务的可靠性。

介绍

根据测试，许多提供服务的提供商所在的网站需要使用外部网络才能打开，仅有少部分的网站(比较贵)可以直接使用
国内网络环境打开直接购买订阅服务。

那么你现在可以有两个选择：

1. 方案一：使用无需外部网络便能开通订阅服务的VPN，费用高，如果你选择此方案，那么你可自行搜索解决，此处仅仅讨论方案二。
2. 方案二：如果使用此方案，详见下方。

解决方案

采用方案二方式

这是一些订阅服务推广的链接： https://9.234456.xyz/abc.html?t=638586217737356738 (此链接打开无需使用VPN，但进入对应的机场页面却仍无法打开)

此教程中我们使用的机场是

1. 一元机场: https://xn--4gq62f52gdss.com/
2. 赔钱机场：https://xn--mes358aby2apfg.com/

机场选择的建议：

• 一元机场
  
  可以看到

  • 12元/年,每月50GB的可用额度，下个月重置流量额度
  • 15元/季，即为60元/年，每月有4000GB的可用额度，下个月重置流量额度
  • 7元/月，即为84元/年，每个月8000GB的可用额度，下个月重置流量额度
    根据我个人的使用情况，大多数情况下我每月的流量使用未超过50GB，如果没有频繁的流量使用，
    建议选择12元/年，否则可以选择15元/季，这意味着每月将有4000GB的可用额度

• 赔钱机场

  
  赔钱机场的订阅共有9种方案，这里我仅显示自己正在使用的，个人认为十分优惠：

  • 34.99元/年,每月500GB的可用额度，根据我观察和使用，这个订阅方案比一元机场的性价比更高，且流量使用额度也不用担心

如何订阅？

完成订阅后如何使用？

你可以在 Windows、Mac、Android等平台使用此服务
使用订阅的对应链接： https://flowus.cn/shenjian/22f76d4f-e7b3-4b8a-8a89-561566f6eb60