机器学习总结基础-1

genfromtxt("world_alcohol.txt", delimiter=",", dtype=str)

arr = np.random.random((4, 6))

score = np.random.randint(80, 100, 30)

arr2 = np.random.randint(0, 10, (4, 4))
arr3 = np.random.randint(0, 10, (4, 4))

arr4 = np.zeros((16, 16))

arr4 = np.ones((2, 3, 4), dtype = np.int32)

arr5 = np.random.randint(0, 100, 10000)

arr.view()

arr.copy()

np.tile(a, (3, 5))

np.sort(a, axis = 1)

i = np.argsort(a)

ver = np.array([5 ,6, 7, 8])

import numpy as np
x = np.array([[1,2,3],[4,5,6]])

world[1, 4]

world[2, 2]

world[0 : 3]

world[:, 1]

world[:, 0:2]

world[1:3, 0:2]

min

max

sum(axis = 0)

A = np.array([[1,1],[0,1]])
B = np.array([[2,0],[3,4]])

# 位置相乘
print (A * B)

# 矩阵乘法
print(A.dot(B))
print(np.dot(A, B))

np.exp(B)

np.sqrt(B)

np.floor

a.rabel()

特征归一化

np.arange(15)

reshape(3, 5)

# 间隔固定数据累加创建数据
x = np.arange(10,30,2)

# 相同间隔创建数据
x = np.linspace(0, 20, 100)

astype(float)

np.hstack([arr2, arr3])

np.vstack([arr2, arr3])

np.hsplit(a, 3)

np.hsplit(a, (3, 4))

np.vsplit(a, 3)

# 最小二乘法，求解方程
# 定义误差函数
# param: 需要求解的直线系数【a, b】, 直线方程为 y = ax + b
# x: 观测数据x
# y: 观测数据y
import numpy as np
from scipy import optimize

def error_fun(param, x, y):
    expect_y = param[0] * x + param[1]
    err = y - expect_y
    return err


x = np.array([1,2,3,4])
y = np.array([6,5,7,10])
# 初始化系数
init_param = np.array([0.1, 0.1])

# 求解
res, k = optimize.leastsq(error_fun, init_param, args=(x, y))
print(res[0], res[1], k)

s1 = pd.Series({'a':11, 'b':22, 'c':33})

s2 = pd.Series([11, 22, 33], index = ['a', 'b', 'c'])

子主题

pd.read_excel

pd.read_csv

dt.head()

dt.head(10)

dt.tail()

dt.tail(10)

dt.columns

dt.shape

过滤数据

loc

按列获取

a_is_null = pd.isnull(a，type=int32)

len(a)

df.apply(func)

iloc

df.fillna(axis = 1)

df.fillna(axis = 0, subset=["age", "name"])

df.dropna()

排序

df.reset_index(drop = True)

pd.to_datetime(a)

df['EK'].max()

min()

mean()

df.sort_values("X", inplace = True)

np.add(a, b)

np.sin(a)

增加列名

删除

数据聚合

创建新列

自定义区间离散化（分箱、分组）

等宽离散化

等深离散化

散点图

柱状图

classes = ["03020" + str(i) for i in range(1, 10)] + ["0302" +  str(i) for i in range(10,31)]
objectes = ["语文","数学","英语","物理","化学","计算机"]
df = pd.DataFrame(np.random.randint(70, 100, (30, 6)),  classes, objectes)

gender = ['男' if np.random.random() < 0.5 else '女' for i in range(30)]
df2 = pd.DataFrame(gender, index = classes, columns = ['性别'])

c = pd.concat([df_cp, df2], axis = 1)

import matplotlib.pyplot as plt

plt.plot(df['a'], df['b'])

plt.show()

plt.xticks(rotation=45)

plt.xlabel('xxxx')

plt.xlabel('yyyy')

plt.title("标题")

fig = plt.figure(figsize=(3, 6))

ax1= fig.add_subplot(2, 2, 1)

ax2=fig.add_subplot(2, 2, 2)

ax4=fig.add_subplot(2, 2, 4)

ax.plot(df)

显式摘要

柱状图

散点图

箱线图

# 绘制前三个特征的直方图
first_three_features = features[:3]
fig, axes = plt.subplots(nrows = 3, ncols = 1, figsize = (8, 10))

for i, feature in enumerate(first_three_features):
    axes[i].hist(X[feature], bins = 30, color='skyblue', edgecolor='black')
    axes[i].set_title(f"{feature} - 直方图")
    axes[i].set_xlabel('值')
    axes[i].set_ylabel('频数')
    axes[i].grid(True, axis = 'y', linestyle='--', linewidth = 0.7, alpha = 0.6)

plt.tight_layout()
plt.show()

df_user['R值_x'].plot(kind = 'hist', bins = 20, title = '新进度分布直方图')

plt.hist(user_id_itemcnt.values)

import seaborn as sns
plt.scatter(df.index, df['A'])
plt.show()

import matplotlib.pyplot as plt
plt.plot(df.index, df['A'], )
plt.show()

# 画密度图
def density_plot(data):
    plt.rcParams['axes.unicode_minus'] = False # 显式正负号
    p = data.plot(kind = 'kde', linewidth = 2, subplots = True, sharex = False, figsize = (10, 9))
    [p[i].set_ylabel(data3.columns[i], fontproperties = 'SimHei') for i in range(k)]
    plt.legend()
    return plt

for i in range(k):
    density_plot(data3)

from sklearn.cluster import KMeans #导入KMeans模块
def show_elbow(df, ax, title):
    distance_list = []
    K = range(1, 9)
    for k in K:
        kmeans = KMeans(n_clusters = k, max_iter = 100)
        kmeans = kmeans.fit(df)
        distance_list.append(kmeans.inertia_)
    ax.plot(K, distance_list, 'bx-')
    ax.set_xlabel('k')
    ax.set_ylabel('距离均方误差')
    ax.set_title(title)

fig, axes = plt.subplots(1, 3, figsize = (18, 6))

show_elbow(df_user[['R值_x']], axes[0], 'R值聚类K值手肘图')
show_elbow(df_user[['F值_x']], axes[1], 'F值聚类K值手肘图')
show_elbow(df_user[['M值_x']], axes[2], 'M值聚类K值手肘图')

plt.tight_layout()
plt.show()

# 误分类矩阵
cnf_matrix = metrics.confusion_matrix(train_y, train_y_pred)
# 绘画分类矩阵
def show_confusion_matrix(cnf_matrix, class_labels):
    plt.matshow(cnf_matrix, cmap=plt.cm.YlGn, alpha = 0.7)
    ax = plt.gca()
    ax.set_xlabel('Predicted Label', fontsize = 16)
    ax.set_xticks(range(0, len(class_labels)))
    ax.set_xticklabels(class_labels, rotation=45)
    ax.set_ylabel('Actual Label', fontsize=16, rotation = 90)
    ax.set_yticks(range(0, len(class_labels)))
    ax.set_yticklabels(class_labels)
    ax.xaxis.set_label_position('top')
    ax.xaxis.tick_top()

    for row in range(len(cnf_matrix)):
        for col in range(len(cnf_matrix[row])):
            ax.text(col, row, cnf_matrix[row][col], va = 'center', ha = 'center', fontsize = 16)

class_labels = [0, 1]
show_confusion_matrix(cnf_matrix, class_labels)

param_range = [0.0001, 0.001, 0.01, 0.1, 1.0, 10.0, 100.0, 1000.0, 10000.0]
train_scores, test_scores = validation_curve(
    estimator = lr, # 指定模型
    X = train_X,
    y = train_y,
    param_name = 'C',
    param_range= param_range,
    cv = 10)

# 计算训练集合测试集准确率的均值和标准差
train_mean = np.mean(train_scores, axis = 1)
train_std = np.std(train_scores, axis = 1)

test_mean = np.mean(test_scores, axis = 1)
test_std = np.std(test_scores, axis = 1)


# 对训练集的准确率作图
plt.plot(param_range, train_mean, color = 'blue', marker='o', markersize = 5, label = 'training accuracy')
# 对训练集准确率的可信范围（上下限）作图： 上限： train_mean + train_std  下限：train_mean - train_std
plt.fill_between(param_range, train_mean + train_std, train_mean - train_std, alpha = 0.15, color = 'blue')

# 对测试集的准确率作图
plt.plot(param_range, test_mean, color = 'blue', marker='o', markersize = 5, label = 'test accuracy')
# 对测试集准确率的可信范围（上下限）作图： 上限： test_mean + test_std  下限：test_mean - test_std
plt.fill_between(param_range, test_mean + test_std, test_mean - test_std, alpha = 0.15, color = 'green')

plt.grid()
plt.xscale('log')
plt.legend(loc= 'lower right')
plt.xlabel('Parmeter')
plt.ylabel('Accuracy')
plt.ylim([0.6, 1.0])
plt.tight_layout()

plt.show()

初始化默认参数

sns.set_style("dark")

调色板

分类色板

圆形画板

样式

bdistplot

jointplot

sns.pairplot(iris)

箱线图

小提琴图

regplot()

stripplot()

swarmplot()

boxplot

barplot

pointplot

factorplot

FacetGrid

组合

import seaborn as sns
from scipy.stats import norm
# 分布 黑色线为正态分布，蓝色为真实分布，房价非正态分布
sns.distplot(train['SalePrice'], fit = norm)

sns.heatmap(corr, vmax = 1, vmin=5, vmax = 10, square = True, center = 0)

center = 0

plt.figure(figsize = (12, 6))
sns.boxplot(x = 'Neighborhood', y = 'SalePrice', data = train)
plt.axis(ymin = 0 , ymax = 800000)
plt.xticks(rotation=90)
plt.show()

# y变量箱线图
train.SalePrice.plot(kind = 'box', sym = 'b*')

corr_cols = corr.loc[:, corr.loc['SalePrice', :].abs() > corr_threshvalue].columns
number_para[corr_cols].plot(sym='b*', kind = 'box', subplots = True, figsize = (20, 8))

count_classes.plot(kind = 'bar')

#小提琴图
import seaborn as sns
plt.figure(figsize = (12, 8))
sns.violinplot(data = pd.DataFrame(X_selected_standardized, columns = selected_features), plaette="Set3")
plt.title('小提琴图-标准化后数据')
plt.ylabel('标准化值')
plt.xticks(rotation = 45)
plt.tight_layout()
plt.show()

from scipy import stats
# 利用Q-Q图判断数据是否偏离正态分布
stats.probplot(train['SalePrice'], plot = plt)

# 聚类数据
from scipy.cluster.hierarchy import linkage, dendrogram # 柱状图

Z = linkage(data3, method = 'ward', metric = 'euclidean')
# 画谱系聚类图
P = dendrogram(Z, 0)
plt.show()

scaler = StandardScaler()
X_standardized = scaler.fit_transform(X)

from sklearn.model_selection import GridSearchCV
svm = SVC()
grid_search = GridSearchCV(svm, parameters, scoring = 'accuracy', cv = 5)
grid_search.fit(x, y)

grid_search.best_estimator_
grid_search.best_score_
grid_search.best_params_

import xgboost as xgb
watchlist = [(dtest, 'val'), (dtrain, 'train')] 
params = {
    'booster':'gbtree',
    'objective':'reg:linear',
    'early_stopping_rounds': 50,
    'eval_metric':'rmse',
    'gamma': 0,
    'max_depth': 5,
    'subsample': 0.6,
    'colsample_bytree': 0.9,
    'min_child_weight': 1,
    'eta': 0.02,
    'seed': 123456,
    'nthread': 3,
    'silent': 0
}
model = xgb.train(params, dtrain, num_boost_round=200, evals = watchlist)
predict_y = model.predict(dtest, ntree_limit = model.best_ntree_limit)

from sklearn.svm import SVC
svm = SVC()
svm.fit(X_train, y_train)

svm.support_
svm.support_vectors_
svm.n_support_
svm.dual_coef_
svm.intercept_

pred = svm.predict(X_test)
print(classification_report(y_test, pred))

from sklearn.neighbors import KNeighborsClassifier
knn = KNeighborsClassifier()
knn.fit(X_train, y_train)

pred = knn.predict(X_test)
print(classification_report(y_test, pred))

kmeans = KMeans(n_clusters = 3)
kmeans.fit(features)

kmeans.cluster_centers_
kmeans.labels_

kmeans.fit_predict(features)
cluster_label = kmeans.predict(features)

from sklearn.ensemble import GradientBoostingRegressor
from sklearn.model_selection import GridSearchCV
gbdt = GradientBoostingRegressor()
gbdt.fit(X_train, y_train)

gbdt.score(X_test, y_test)

print(gbdt.feature_importances_)

from sklearn.ensemble import GradientBoostingRegressor
from sklearn.model_selection import GridSearchCV
gbdt = GradientBoostingClassifier()
gbdt.fit(X_train, y_train)

gbdt.score(X_test, y_test)

print(gbdt.feature_importances_)

from sklearn.ensemble import AdaBoostRegressor
from sklearn.tree import DecisionTreeRegressor
from sklearn.model_selection import GridSearchCV

dtree = DecisionTreeRegressor()
adaboost = AdaBoostRegressor(base_estimator = dtree)
adaboost.fit(X_train, y_train)

adaboost.score(X_test, y_test)

print(adaboost.feature_importances_)

from sklearn.ensemble import AdaBoostClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import GridSearchCV

dtree = DecisionTreeClassifier()
adaboost = AdaBoostClassifier(base_estimator = dtree)
adaboost.fit(X_train, y_train)

adaboost.score(X_test, y_test)

print(adaboost.feature_importances_)

一元线性回归

多元线性回归

非线性回归

from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import GridSearchCV

rf = RandomForestRegressor()
rf.fit(X_train, y_train)

rf.score(X_test, y_test)

print(iris.feature_names)
print(rf.feature_importances_)

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import GridSearchCV

rf = RandomForestClassifier()
rf.fit(X_train, y_train)

rf.score(X_test, y_test)

print(iris.feature_names)
print(rf.feature_importances_)

from sklearn.linear_model import LogisticRegression
from sklearn import metrics

from sklearn.metrics import confusion_matrix
from sklearn.metrics import precision_score
from sklearn.metrics import recall_score
from sklearn.metrics import f1_score
from sklearn.metrics import accuracy_score
from sklearn.metrics import classification_report

lr = LogisticRegression()
lr.fit(X_train, y_train)

y_train_pred = lr.predict(X_train)
classification_report(y_train, y_train_pred)

y_test_pred = lr.predict(X_test)
classification_report(y_test, y_test_pred)

lr.intercept_
lr.coef_
pd.DataFrame(list(zip(np.transpose(lr.coef_), train_X.columns)), columns = ['coef', 'columns'])

多分类

from sklearn import tree

from sklearn import metrics
from sklearn.metrics import confusion_matrix
from sklearn.metrics import precision_score
from sklearn.metrics import recall_score
from sklearn.metrics import f1_score
from sklearn.metrics import accuracy_score
from sklearn.metrics import classification_report

dtree = tree.DecisionTreeClassifier(max_depth = 3)
dtree.fit(X_train, y_train)

dtree.classes_
dtree.feature_importances_
dtree.max_features_
dtree.n_classes_
dtree.n_features_in_
dtree.n_outputs_
dtree.tree_

pred = dtree.predict(X_test)
print(classification_report(y_test, pred))

from sklearn import tree
dtree = tree.DecisionTreeRegressor(max_depth=3)
dtree.fit(X_train, y_train)

from sklearn.metrics import explained_variance_score
from sklearn.metrics import mean_absolute_error
from sklearn.metrics import mean_squared_error
from sklearn.metrics import r2_score

y_pred = dtree.predict(X_test)
# 解释方差
explained_variance_score(y_test, y_pred)
# 绝对平均误差
mean_absolute_error(y_test, y_pred)
# 均方误差
mean_squared_error(y_test, y_pred)
# 决定系数 R2
r2_score(y_test, y_pred)

GaussianNB

MultinomialNB

BernoulliNB