keithic

section8

### 本章节的目的是【明确目标用户群】，以更好的服务现有用户。 ### 【知识点】 ### 1.作图 - 显示中文 ` plt.rcParams[‘font.sans-serif’] = [‘SimHei’] # 步骤一（替换sans-serif字体） plt.rcParams[‘axes.unicode_minus’] = False # 步骤二（解决坐标轴负数的负号显示问题）` ### 2.数据库操作 - sqlalchemy 引擎 ` engine = create_engine(‘mysql+pymysql://root:123456@localhost:3306/datascience’) ` ### 3.批量读取文件 - os.wolk()、os.path.join()用法

for root, dirs, files in os.walk(path): 
        for file in files:`
            rfile = os.path.join(root,file)
            if rfile.split('.')[-1] == 'tsv':
                rdf = pd.read_csv(rfile, sep='\t')
                df = df.append(rdf)

### 4.groupby()以及agg() 的联合使用，应对不同列使用不同的函数 - 按月统计 ` affc = {‘payment’:’sum’, ‘log_date’:’count’} dfm = df.groupby([‘log_month’, ‘user_id’]).agg(affc).reset_index() ` - 修改列明 ` renam = {‘log_date’:’access_days’} dfm.rename(columns=renam, inplace=True) ` ### 5.KMeans 聚类的使用 - 单列的聚类（需要将单列应用 reshape（-1,1）格式化为1列） `from sklearn.cluster import KMeans a47 = action[‘A47’].reshape(-1, 1) kms = KMeans(n_clusters=3).fit(a47)` - 聚类的标签 labels_ 属性 `cluster = kms.labels_` - 将标签添加至源数据中，运用groupby（）查看分组情况 `action[‘cluster’] = cluster action.groupby([‘cluster’])[‘user_id’].count()` - 可视化分组

snsdf = action[['user_id','A47','cluster']].sort_values(by='A47',ascending=False)
plt.figure(figsize=(8,5))
snsdf1 = snsdf.reset_index()
snsdf1[snsdf1['cluster']==2]['A47'].plot(color='r',label='2:重度用户')
snsdf1[snsdf1['cluster']==1]['A47'].plot(color='g',label='1:中度用户')
snsdf1[snsdf1['cluster']==0]['A47'].plot(color='b',label='0:轻度用户')
plt.legend()
plt.xlabel('用户分布')
plt.ylabel('排行榜得分')

### 6.主成分分析 - 数据预处理 - - 提取要进行主成分分析的列 `paction = acc.iloc[:,3:(len(acc.columns)-1)]` - - 删掉0值较多的列 `cc = paction[paction==0].count(axis=0)/len(paction) cc.plot() dd = cc[cc ### 一、库导入以及matplotlib显示中文

import pandas as pd
import numpy as np
import pymysql
from sqlalchemy import create_engine
import matplotlib.pyplot as plt
import seaborn as sns
import missingno as msno
import os

plt.rcParams['font.sans-serif'] = ['SimHei'] # 步骤一（替换sans-serif字体）
plt.rcParams['axes.unicode_minus'] = False   # 步骤二（解决坐标轴负数的负号显示问题）
%matplotlib inline

数据库引擎

engine = create_engine('mysql+pymysql://root:123456@localhost:3306/datascience')

### 二、批量读取文件

def read_files(path):
    df = pd.DataFrame()
    for root, dirs, files in os.walk(path):
        for file in files:
            rfile = os.path.join(root,file)
            if rfile.split('.')[-1] == 'tsv':
                rdf = pd.read_csv(rfile, sep='\t')
                df = df.append(rdf)
    return df

action_path  = 'data/sample-data/section8/daily/action/'
dau_path = 'data/sample-data/section8/daily/dau/'
dpu_path = 'data/sample-data/section8/daily/dpu/'

action = read_files(action_path)
dau = read_files(dau_path)
dpu = read_files(dpu_path)

查看数据完整性以及头部信息

print(action.isnull().sum().sum())
print(action.shape)
# print(action.info())
action.head()

0 (2653, 57)

.dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; }

	log_date	app_name	user_id	A2	A5	A6	A7	…	A45	A46	A47	A48	A49	A50	A51	A54
0	2013-10-31	game-01	654133	0	0	0	0	…	0	0	380	25655	0	0	0	46
1	2013-10-31	game-01	425530	0	10	1	233	…	19	20	180543	347	36	22	4	71
2	2013-10-31	game-01	709596	0	0	0	0	…	0	0	416	24817	0	0	0	2
3	2013-10-31	game-01	525047	2	9	0	0	…	22	22	35200	6412	21	0	0	109
4	2013-10-31	game-01	796908	0	0	0	0	…	29	29	388	25444	1	0	0	64

5 rows × 57 columns

print(dau.isnull().sum().sum())
print(dau.shape)
print(dau.info())
dau.head()

0 (509754, 3)

print(dpu.isnull().sum().sum())
print(dpu.shape)
print(dpu.info())
dpu.head()

0 (3532, 4)

# 写入数据库

# action.to_sql('s8_action', engine, index=False)
# dau.to_sql('s8_dau', engine, index=False)
# dpu.to_sql('s8_dpu', engine, index=False)

## 三、数据预处理 ### 1.合并 DAU DPU

df = pd.merge(dau, dpu[['log_date','user_id','payment']], how='left', on=['user_id','log_date'])
df.head()

.dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; }

	log_date	app_name	user_id	payment
0	2013-05-01	game-01	608801	NaN
1	2013-05-01	game-01	712453	NaN
2	2013-05-01	game-01	776853	NaN
3	2013-05-01	game-01	823486	NaN
4	2013-05-01	game-01	113600	NaN

# 将无消费记录的消费额设为 0 
print(df.payment.isnull().sum())
df['payment'].fillna(0, inplace=True)
print(df.payment.isnull().sum())

507151 0

# 添加消费额标志位
df['is_pay'] = df['payment'].apply( lambda x: 1 if x>0 else 0 )
df.head()

.dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; }

	log_date	app_name	user_id
0	2013-05-01	game-01	608801
1	2013-05-01	game-01	712453
2	2013-05-01	game-01	776853
3	2013-05-01	game-01	823486
4	2013-05-01	game-01	113600

### 2.按月统计

# 增加月份列
df['log_month'] = df['log_date'].apply(lambda x: x[0:7])
df.head()

.dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; }

	log_date	app_name	user_id	log_month
0	2013-05-01	game-01	608801	2013-05
1	2013-05-01	game-01	712453	2013-05
2	2013-05-01	game-01	776853	2013-05
3	2013-05-01	game-01	823486	2013-05
4	2013-05-01	game-01	113600	2013-05

巧妙运用 groupby 以及 agg 函数，统计出用户按月份的消费情况和登陆次数

# 按月统计
affc = {'payment':'sum', 'log_date':'count'}
dfm = df.groupby(['log_month', 'user_id']).agg(affc).reset_index()
# 修改列明
renam = {'log_date':'access_days'}
dfm.rename(columns=renam, inplace=True)
dfm.head()

.dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; }

	log_month	user_id	access_days
0	2013-05	65	1
1	2013-05	115	1
2	2013-05	194	1
3	2013-05	426	4
4	2013-05	539	1

### 4.使用 Kmeans 进行分类，得到排名靠前的用户，即重度用户/中度用户/轻度用户 A47 列即是排行榜得分，从分布图上看出，大部分用户得分很低，符合幂律曲线

# 
action['A47'].hist(bins=50, figsize=(6,4))

sns.distplot(action['A47'],bins=50,kde=True)

#### 对 A47 列进行聚类，分为3类

from sklearn.cluster import KMeans

a47 = action['A47'].reshape(-1, 1)

kms = KMeans(n_clusters=3).fit(a47)

D:\ProgramData\Anaconda3\lib\site-packages\ipykernel_launcher.py:3: FutureWarning: reshape is deprecated and will raise in a subsequent release. Please use .values.reshape(…) instead This is separate from the ipykernel package so we can avoid doing imports until

cluster = kms.labels_
kms.cluster_centers_

array([[ 9359.84787792], [ 69386.11297071], [185857.17948718]])

action['cluster'] = cluster
action.head()

.dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; }

	log_date	app_name	user_id	A2	A5	A6	A7	…	A46	A47	A48	A49	A50	A51	A54	cluster
0	2013-10-31	game-01	654133	0	0	0	0	…	0	380	25655	0	0	0	46	0
1	2013-10-31	game-01	425530	0	10	1	233	…	20	180543	347	36	22	4	71	2
2	2013-10-31	game-01	709596	0	0	0	0	…	0	416	24817	0	0	0	2	0
3	2013-10-31	game-01	525047	2	9	0	0	…	22	35200	6412	21	0	0	109	0
4	2013-10-31	game-01	796908	0	0	0	0	…	29	388	25444	1	0	0	64	0

5 rows × 58 columns

action.groupby(['cluster'])['user_id'].count()

cluster 0 2096 1 479 2 78 Name: user_id, dtype: int64 图上显示，通过聚类分解后用户分为3个类， 0 表示轻度用户，排行榜得分最少； 1 表示中度用户，排行版得分居中； 2 表示重度用户，排行版得分较高，而且用户数量较少，符合实际情况。

snsdf = action[['user_id','A47','cluster']].sort_values(by='A47',ascending=False)
snsdf['user'] = range(len(snsdf))
sns.scatterplot(x='user',y='A47',hue='cluster',data=snsdf, palette='rainbow', alpha=.2)

snsdf = action[['user_id','A47','cluster']].sort_values(by='A47',ascending=False)
snsdf['user'] = range(len(snsdf))

plt.figure(figsize=(8,5))
snsdf1 = snsdf.reset_index()
snsdf1[snsdf1['cluster']==2]['A47'].plot(color='r',label='2:重度用户')
snsdf1[snsdf1['cluster']==1]['A47'].plot(color='g',label='1:中度用户')
snsdf1[snsdf1['cluster']==0]['A47'].plot(color='b',label='0:轻度用户')
plt.legend()
plt.xlabel('用户分布')
plt.ylabel('排行榜得分')

Text(0,0.5,’排行榜得分’) ![png](output_33_1.png) #### 限定排名靠前的用户，即得分较高的重度和中度用户，以便接下来进行分析

acc = action[action['cluster']>=1]
acc.head()

.dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; }

	log_date	app_name	user_id	A5	A6	A7	…	A46	A47	A48	A49	A50	A51	A54	cluster
1	2013-10-31	game-01	425530	10	1	233	…	20	180543	347	36	22	4	71	2
5	2013-10-31	game-01	776120	9	0	0	…	38	142214	684	37	15	0	312	2
7	2013-10-31	game-01	276197	7	0	58	…	15	54602	4226	15	0	8	95	1
8	2013-10-31	game-01	221572	1	0	0	…	24	39891	5792	4	0	0	21	1
9	2013-10-31	game-01	692433	6	0	0	…	28	50706	4549	16	8	0	154	1

5 rows × 58 columns

## 5.主成分分析获取关键的参数

paction = acc.iloc[:,3:(len(acc.columns)-1)]
paction.index=acc.user_id
paction.head()

.dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; }

	A1	A2	A3	A4	A5	A6	A7	A8	A9	A10	…	A45	A46	A47	A48	A49	A50	A51	A52	A53	A54
user_id
425530	0	0	0	0	10	1	233	58.25	288	230	…	19	20	180543	347	36	22	4	0	0.0	71
776120	0	0	0	0	9	0	0	0.00	325	195	…	19	38	142214	684	37	15	0	0	0.0	312
276197	0	0	0	0	7	0	58	7.25	150	100	…	15	15	54602	4226	15	0	8	0	0.0	95
221572	0	0	0	0	1	0	0	0.00	40	14	…	24	24	39891	5792	4	0	0	0	0.0	21
692433	0	0	0	0	6	0	0	0.00	102	95	…	15	28	50706	4549	16	8	0	0	0.0	154

5 rows × 54 columns

#### 1.删掉 0 值比较多的列

cc = paction[paction==0].count(axis=0)/len(paction)
print(cc.head())
cc.plot()

A1 1.000000 A2 0.926391 A3 1.000000 A4 0.994614 A5 0.055655 dtype: float64

# cc[cc>.8]

dd = cc[cc<.95]

paction = paction[dd.index]
paction.head()

.dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; }

	A2	A5	A6	A7	A8	A9	A10	A11	A12	A13	…	A45	A46	A47	A48	A49	A50	A51	A52	A53	A54
user_id
425530	0	10	1	233	58.25	288	230	19	2	19	…	19	20	180543	347	36	22	4	0	0.0	71
776120	0	9	0	0	0.00	325	195	38	8	19	…	19	38	142214	684	37	15	0	0	0.0	312
276197	0	7	0	58	7.25	150	100	15	3	11	…	15	15	54602	4226	15	0	8	0	0.0	95
221572	0	1	0	0	0.00	40	14	0	0	3	…	24	24	39891	5792	4	0	0	0	0.0	21
692433	0	6	0	0	0.00	102	95	0	0	2	…	15	28	50706	4549	16	8	0	0	0.0	154

5 rows × 32 columns

#### 2.删掉相关性较强的列

corp = paction.corr()
plt.figure(figsize=(15,8))
sns.heatmap(corp)

mask = np.array(corp)
mask[np.tril_indices_from(mask)] = False
fig,ax = plt.subplots()
fig.set_size_inches(15,8)
sns.heatmap(corp,mask=mask)

coll = corp.columns
corp = pd.DataFrame(np.tril(corp, -1))
corp.columns = coll
corp.head()

.dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; }

	A2	A5	A6	A7	…
0	0.000000	0.000000	0.000000	0.000000	…
1	0.069744	0.000000	0.000000	0.000000	…
2	0.076185	0.178833	0.000000	0.000000	…
3	0.158735	0.219395	0.371360	0.000000	…
4	0.167200	0.186124	0.242025	0.803161	…

5 rows × 32 columns

pac2 = paction.loc[:,(corp.abs()<.7).all()]      # 任何一个数都小于0.7 的数据
pac2.head()

.dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; }

	A2	A11	A12	A13	A20	A23	A24	A43	A44	A46	A48	A49	A50	A51	A53	A54
user_id
425530	0	19	2	19	0	0	0.5	23	0.92174	20	347	36	22	4	0.0	71
776120	0	38	8	19	0	0	0.0	20	0.90256	38	684	37	15	0	0.0	312
276197	0	15	3	11	0	0	0.0	10	0.92000	15	4226	15	0	8	0.0	95
221572	0	0	0	3	0	0	0.0	2	0.85714	24	5792	4	0	0	0.0	21
692433	0	0	0	2	0	0	0.0	11	0.73684	28	4549	16	8	0	0.0	154

### 进行主成分分析

from sklearn.decomposition import PCA

pca = PCA()
pca.fit(pac2)

PCA(copy=True, iterated_power=’auto’, n_components=None, random_state=None, svd_solver=’auto’, tol=0.0, whiten=False)

redio = pca.explained_variance_ratio_
print(redio) 
print(pca.singular_values_)

[9.97843804e-01 1.92024564e-03 1.20120771e-04 5.57014208e-05 2.67905481e-05 1.54533752e-05 9.31262940e-06 4.38846214e-06 3.02317261e-06 8.36725295e-07 1.31874979e-07 9.78197162e-08 3.86464536e-08 2.94647596e-08 1.82272465e-08 7.54580333e-09] [3.96183910e+04 1.73797668e+03 4.34684952e+02 2.96004755e+02 2.05284590e+02 1.55911168e+02 1.21032418e+02 8.30848288e+01 6.89599635e+01 3.62791414e+01 1.44027941e+01 1.24044853e+01 7.79687146e+00 6.80796010e+00 5.35458829e+00 3.44523057e+00]

recu = redio.cumsum()
print(recu)
x = np.arange(len(recu))
plt.plot(recu, color='r')

[0.9978438 0.99976405 0.99988417 0.99993987 0.99996666 0.99998212 0.99999143 0.99999582 0.99999884 0.99999968 0.99999981 0.99999991 0.99999994 0.99999997 0.99999999 1. ] [ #### 得到降维后的数据

pca.set_params(n_components=10)
pac3 = pd.DataFrame(pca.fit_transform(pac2))
pacsse = pac3.copy()
pac3.head()

.dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; }

	0	1	2	3	4	5	6	7	8	9
0	2706.266005	-100.824346	-1.874787	-1.577536	12.481591	-2.394320	9.770878	7.807535	0.021273	-2.169596
1	2373.811140	147.314930	-16.386795	-8.428655	10.019577	-3.004725	6.009771	0.961469	-1.598531	2.144615
2	-1171.733361	-5.493081	0.744995	0.542033	-0.785251	-5.756412	-1.012336	-1.778067	7.256884	0.343277
3	-2738.903900	-50.468487	2.328491	2.965415	-5.794347	11.891289	2.965366	-1.182413	0.065619	1.245358
4	-1493.642618	58.686385	-10.807612	11.777973	7.664692	9.312968	4.376429	1.994214	-1.568050	0.426246

## 6.KMeans 进行聚类

from sklearn.cluster import KMeans

km = KMeans(n_clusters=5)
km.fit(pac3)

KMeans(algorithm=’auto’, copy_x=True, init=’k-means++’, max_iter=300, n_clusters=5, n_init=10, n_jobs=1, precompute_distances=’auto’, random_state=None, tol=0.0001, verbose=0)

clu = km.labels_
pac3['clu'] = clu
pac3.head()

.dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; }

	0	1	2	3	4	5	6	7	8	9	clu
0	2706.266005	-100.824346	-1.874787	-1.577536	12.481591	-2.394320	9.770878	7.807535	0.021273	-2.169596	0
1	2373.811140	147.314930	-16.386795	-8.428655	10.019577	-3.004725	6.009771	0.961469	-1.598531	2.144615	0
2	-1171.733361	-5.493081	0.744995	0.542033	-0.785251	-5.756412	-1.012336	-1.778067	7.256884	0.343277	1
3	-2738.903900	-50.468487	2.328491	2.965415	-5.794347	11.891289	2.965366	-1.182413	0.065619	1.245358	4
4	-1493.642618	58.686385	-10.807612	11.777973	7.664692	9.312968	4.376429	1.994214	-1.568050	0.426246	1

pac3.groupby('clu')[2].count()

clu 0 90 1 113 2 122 3 109 4 123 Name: 2, dtype: int64 #### palette 的颜色风格： Accent, Accent_r, Blues, Blues_r, BrBG, BrBG_r, BuGn, BuGn_r, BuPu, BuPu_r, CMRmap, CMRmap_r, Dark2, Dark2_r, GnBu, GnBu_r, Greens, Greens_r, Greys, Greys_r, OrRd, OrRd_r, Oranges, Oranges_r, PRGn, PRGn_r, Paired, Paired_r, Pastel1, Pastel1_r, Pastel2, Pastel2_r, PiYG, PiYG_r, PuBu, PuBuGn, PuBuGn_r, PuBu_r, PuOr, PuOr_r, PuRd, PuRd_r, Purples, Purples_r, RdBu, RdBu_r, RdGy, RdGy_r, RdPu, RdPu_r, RdYlBu, RdYlBu_r, RdYlGn, RdYlGn_r, Reds, Reds_r, Set1, Set1_r, Set2, Set2_r, Set3, Set3_r, Spectral, Spectral_r, Vega10, Vega10_r, Vega20, Vega20_r, Vega20b, Vega20b_r, Vega20c, Vega20c_r, Wistia, Wistia_r, YlGn, YlGnBu, YlGnBu_r, YlGn_r, YlOrBr, YlOrBr_r, YlOrRd, YlOrRd_r, afmhot, afmhot_r, autumn, autumn_r, binary, binary_r, bone, bone_r, brg, brg_r, bwr, bwr_r, cool, cool_r, coolwarm, coolwarm_r, copper, copper_r, cubehelix, cubehelix_r, flag, flag_r, gist_earth, gist_earth_r, gist_gray, gist_gray_r, gist_heat, gist_heat_r, gist_ncar, gist_ncar_r, gist_rainbow, gist_rainbow_r, gist_stern, gist_stern_r, gist_yarg, gist_yarg_r, gnuplot, gnuplot2, gnuplot2_r, gnuplot_r, gray, gray_r, hot, hot_r, hsv, hsv_r, icefire, icefire_r, inferno, inferno_r, jet, jet_r, magma, magma_r, mako, mako_r, nipy_spectral, nipy_spectral_r, ocean, ocean_r, pink, pink_r, plasma, plasma_r, prism, prism_r, rainbow, rainbow_r, rocket, rocket_r, seismic, seismic_r, spectral, spectral_r, spring, spring_r, summer, summer_r, tab10, tab10_r, tab20, tab20_r, tab20b, tab20b_r, tab20c, tab20c_r, terrain, terrain_r, viridis, viridis_r, vlag, vlag_r, winter, winter_r

plt.figure(figsize=(13,7))
sns.scatterplot(x=0, y=1, data=pac3,style='clu',hue='clu', palette='autumn')

### 将分类后的类别添加至原数据中

pac4 = pac2.copy()
pac4['cluster'] = list(pac3.clu)
pac4.head()

.dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; }

	A2	A11	A12	A13	A20	A23	A24	A43	A44	A46	A48	A49	A50	A51	A53	A54	cluster
user_id
425530	0	19	2	19	0	0	0.5	23	0.92174	20	347	36	22	4	0.0	71	0
776120	0	38	8	19	0	0	0.0	20	0.90256	38	684	37	15	0	0.0	312	0
276197	0	15	3	11	0	0	0.0	10	0.92000	15	4226	15	0	8	0.0	95	1
221572	0	0	0	3	0	0	0.0	2	0.85714	24	5792	4	0	0	0.0	21	4
692433	0	0	0	2	0	0	0.0	11	0.73684	28	4549	16	8	0	0.0	154	1

# 计算每个类的平均值
clu5 = pac4.groupby('cluster').mean()

# 删除相关性较高的列
clu5.drop(columns='A53',inplace=True)
c5cor = clu5.corr()
plt.figure(figsize=(15,8))
sns.heatmap(c5cor,annot=True)

ccrp = pd.DataFrame(np.tril(c5cor,-1))
ccrp.columns = clu5.columns
cccc = clu5.loc[:,(ccrp.abs()<.95).all()]
cccc

.dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; }

	A2	A20	A23	A24	A44	A46	A50	A51	A54
cluster
0	0.022222	0.322222	0.655556	0.167691	0.858193	27.600000	10.666667	2.011111	166.711111
1	0.079646	0.274336	0.362832	0.095231	0.844027	20.159292	3.008850	1.469027	102.106195
2	0.073770	0.377049	0.336066	0.070628	0.849343	24.737705	4.286885	1.844262	121.909836
3	0.018349	0.229358	0.284404	0.098252	0.845981	24.119266	5.266055	1.733945	146.871560
4	0.203252	0.292683	0.243902	0.063686	0.775076	18.983740	2.130081	0.975610	84.032520

from sklearn.preprocessing import scale

ccccc = pd.DataFrame(scale(cccc))

ccccc.columns = cccc.columns
ccccc

.dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; }

	A2	A20	A23	A24	A44	A46	A50	A51	A54
0	-0.855590	0.468859	1.918400	1.862020	0.785882	1.422970	1.867773	1.118457	1.424282
1	0.002962	-0.503392	-0.094337	-0.104961	0.315530	-0.940402	-0.688647	-0.381093	-0.746672
2	-0.084884	1.582038	-0.278379	-0.772826	0.492038	0.513827	-0.261998	0.656909	-0.081200
3	-0.913505	-1.416613	-0.633601	-0.022944	0.380387	0.317394	0.064879	0.351742	0.757602
4	1.851016	-0.130892	-0.912083	-0.961289	-1.973837	-1.313789	-0.982007	-1.746015	-1.354012

plt.figure(figsize=(8,8))
# 极坐标的分割分数
N = ccccc.shape[1]
# 设置雷达图的角度，用于平分切开一个圆面
angles = np.linspace(0, 2*np.pi, N, endpoint=False)
# 使雷达图一圈封闭起来
angles = np.concatenate((angles,[angles[0]]))
for i in range(len(ccccc)):
    # 构造数据
    values = ccccc.loc[i,:]
    # 为了使雷达图一圈封闭起来
    values = np.concatenate((values,[values[0]]))
    # 绘制
    plt.polar(angles, values, 'o-', linewidth=2)
plt.legend(ccccc.index, loc='lower right')
# 添加极坐标的标签
plt.thetagrids(angles * 180/np.pi, labels=list(ccccc.columns))
plt.title('重要指标雷达图呈现')

Text(0.5,1.05,’重要指标雷达图呈现’) ![png](output_70_1.png) ## 不进行预处理的降维

dfp = acc.iloc[:,3:(len(acc.columns)-1)]
dfp.index=acc.user_id
dfp.head()

.dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; }

	A1	A2	A3	A4	A5	A6	A7	A8	A9	A10	…	A45	A46	A47	A48	A49	A50	A51	A52	A53	A54
user_id
425530	0	0	0	0	10	1	233	58.25	288	230	…	19	20	180543	347	36	22	4	0	0.0	71
776120	0	0	0	0	9	0	0	0.00	325	195	…	19	38	142214	684	37	15	0	0	0.0	312
276197	0	0	0	0	7	0	58	7.25	150	100	…	15	15	54602	4226	15	0	8	0	0.0	95
221572	0	0	0	0	1	0	0	0.00	40	14	…	24	24	39891	5792	4	0	0	0	0.0	21
692433	0	0	0	0	6	0	0	0.00	102	95	…	15	28	50706	4549	16	8	0	0	0.0	154

5 rows × 54 columns

from sklearn.decomposition import PCA

pca = PCA(whiten=False)
pca.fit(dfp)

PCA(copy=True, iterated_power=’auto’, n_components=None, random_state=None, svd_solver=’auto’, tol=0.0, whiten=False)

retio = pca.explained_variance_ratio_
# print(retio) 
# print(pca.singular_values_)  

rec = retio.cumsum()
print(rec)
x = np.arange(len(rec))
plt.plot(rec, color='r')

[0.9996008 0.99995245 0.99997489 0.99999016 0.9999933 0.99999564 0.99999759 0.99999838 0.99999897 0.9999995 0.99999962 0.99999972 0.99999979 0.99999986 0.9999999 0.99999993 0.99999996 0.99999997 0.99999997 0.99999998 0.99999998 0.99999999 0.99999999 0.99999999 0.99999999 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. 1. ] [

pca.set_params(n_components=10)
pacsse = pd.DataFrame(pca.fit_transform(dfp))
pacsse.head()

.dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; }

	0	1	2	3	4	5	6	7	8	9
0	94938.293061	-342.891655	-161.442878	-199.616210	1.830692	73.107938	153.124982	124.440657	-34.371612	46.548951
1	56613.313155	-960.580156	-38.560364	-45.836571	13.670166	90.767620	-145.846645	-40.255134	10.508203	16.287863
2	-31060.195159	388.005529	-6.932692	-0.948812	-5.332728	18.237293	11.393467	14.689011	-7.994909	32.398532
3	-45806.252443	1579.357883	-81.812845	-96.488345	-18.477649	-90.059217	31.377291	-22.865193	-19.724837	16.293640
4	-34963.135693	611.858506	-18.187490	-16.454233	-5.597209	-9.722257	-63.112236	-3.943266	7.222725	-10.889839

## 手肘法获取最优 K 值

from sklearn.cluster import KMeans

df_features = pacsse # 读入数据
# '利用SSE选择k'
SSE = []  # 存放每次结果的误差平方和
for k in range(1,9):
    estimator = KMeans(n_clusters=k)  # 构造聚类器
    estimator.fit(df_features)
    SSE.append(estimator.inertia_)
X = range(1,9)
plt.xlabel('k')
plt.ylabel('SSE')
plt.plot(X,SSE,'o-')

[ #### 显然，先标准化数据是不合适的

# 显然，先标准化数据是不合适的

df_features = pd.DataFrame(scale(pacsse)) 

SSE = []  
for k in range(1,9):
    estimator = KMeans(n_clusters=k) 
    estimator.fit(df_features)
    SSE.append(estimator.inertia_)
X = range(1,9)
plt.xlabel('k')
plt.ylabel('SSE')
plt.plot(X,SSE,'o-')

[

km = KMeans(n_clusters=4)
km.fit(pacsse)
clu = km.labels_
pacsse['clu'] = clu
pacsse.head()

.dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; }

	0	1	2	3	4	5	6	7	8	9	clu
0	94938.293061	-342.891655	-161.442878	-199.616210	1.830692	73.107938	153.124982	124.440657	-34.371612	46.548951	2
1	56613.313155	-960.580156	-38.560364	-45.836571	13.670166	90.767620	-145.846645	-40.255134	10.508203	16.287863	0
2	-31060.195159	388.005529	-6.932692	-0.948812	-5.332728	18.237293	11.393467	14.689011	-7.994909	32.398532	1
3	-45806.252443	1579.357883	-81.812845	-96.488345	-18.477649	-90.059217	31.377291	-22.865193	-19.724837	16.293640	1
4	-34963.135693	611.858506	-18.187490	-16.454233	-5.597209	-9.722257	-63.112236	-3.943266	7.222725	-10.889839	1

pacsse.groupby('clu')[2].count()

clu 0 153 1 344 2 54 3 6 Name: 2, dtype: int64

plt.figure(figsize=(13,7))
sns.scatterplot(x=0, y=1, data=pacsse,style='clu',hue='clu', palette='autumn')

### 显然，不进行预处理的数据聚类是有问题的，第一主成分和第二主成分显然是相关的

pac4 = pac2.copy()
pac4['cluster'] = list(pacsse.clu)
pac4.head()

clu5 = pac4.groupby('cluster').mean()
clu5.drop(columns='A53',inplace=True)
c5cor = clu5.corr()
plt.figure(figsize=(15,8))
sns.heatmap(c5cor,annot=True)

ccrp = pd.DataFrame(np.tril(c5cor,-1))
ccrp.columns = clu5.columns
cccc = clu5.loc[:,(ccrp.abs()<.95).all()]
cccc

.dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; }

	A12	A20	A51	A54
cluster
0	3.398693	0.228758	1.810458	146.287582
1	1.938953	0.316860	1.433140	101.531977
2	4.592593	0.407407	1.870370	169.777778
3	2.166667	0.166667	1.666667	213.833333

from sklearn.preprocessing import scale

ccccc = pd.DataFrame(scale(cccc))

ccccc.columns = cccc.columns
ccccc

.dataframe tbody tr th:only-of-type { vertical-align: middle; } .dataframe tbody tr th { vertical-align: top; } .dataframe thead th { text-align: right; }

	A12	A20	A51	A54
0	0.352533	-0.562784	0.684599	-0.285229
1	-1.021705	0.406288	-1.555764	-1.388557
2	1.476502	1.402249	1.040338	0.293858
3	-0.807330	-1.245753	-0.169173	1.379928

plt.figure(figsize=(8,8))
# 极坐标的分割分数
N = ccccc.shape[1]
# 设置雷达图的角度，用于平分切开一个圆面
angles = np.linspace(0, 2*np.pi, N, endpoint=False)
# 使雷达图一圈封闭起来
angles = np.concatenate((angles,[angles[0]]))
for i in range(len(ccccc)):
    # 构造数据
    values = ccccc.loc[i,:]
    # 为了使雷达图一圈封闭起来
    values = np.concatenate((values,[values[0]]))
    # 绘制
    plt.polar(angles, values, 'o-', linewidth=2)
plt.legend(ccccc.index, loc='lower right')
# 添加极坐标的标签
plt.thetagrids(angles * 180/np.pi, labels=list(ccccc.columns))
plt.title('重要指标雷达图呈现')

Text(0.5,1.05,'重要指标雷达图呈现')

你可能感兴趣的:(机器学习实战)

机器学习实战笔记5——线性判别分析绍少阿机器学习笔记可视化机器学习 python 人工智能
任务安排1、机器学习导论8、核方法2、KNN及其实现9、稀疏表示3、K-means聚类10、高斯混合模型4、主成分分析11、嵌入学习5、线性判别分析12、强化学习6、贝叶斯方法13、PageRank7、逻辑回归14、深度学习线性判别分析（LDA）Ⅰ核心思想对于同样一件事，站在不同的角度，我们往往会有不同的看法，而降维思想，亦是如此。同上节课一样，我们还是学习降维的算法，只是提供了一种新的角度，由上
机器学习实战----波士顿房价预测模型永远偷渡不了的非洲人机器学习机器学习 sklearn python
波士顿房价模型预测是一个回归问题，可以采用r2_score方法来作为评价指标。importnumpyasnpimportpandasaspdfromsklearn.metricsimportr2_score#从sklearn的数据库中导入波士顿房产数据fromsklearn.datasetsimportload_bostonfromsklearn.model_selectionimporttrai
python logistic模型_Python实践之逻辑回归（Logistic Regression） weixin_39922394 python logistic模型
机器学习算法与Python实践这个系列主要是参考《机器学习实战》这本书。因为自己想学习Python，然后也想对一些机器学习算法加深下了解，所以就想通过Python来实现几个比较常用的机器学习算法。恰好遇见这本同样定位的书籍，所以就参考这本书的过程来学习了。这节学习的是逻辑回归(LogisticRegression)，也算进入了比较正统的机器学习算法。啥叫正统呢？我概念里面机器学习算法一般是这样一个
(二十一)Seaborn知识学习8-python数据分析与机器学习实战(学习笔记) 努力奋斗的durian
文章原创,最近更新：2018-05-17课程来源:python数据分析与机器学习实战-唐宇迪引言:介绍seaborn热度图绘制学习参考链接:1、Seaborn官方0.8.1版本首先介绍以下热度图的作用,拿出离散群数据,离散群数据可能会发生波动变化.看一下哪个点的值比较高,看一下哪个点的值比较低?通过值的变化,用颜色表现出来,这个是我们要做的一件事.热度图是由不同的颜色构成的,这个颜色由可能是由浅入
机器学习实战2--蒙特卡洛方法与Q-Q图(2022/10/12) 点灯的棉羊机器学习Jupyter笔记机器学习人工智能 numpy python
蒙特卡洛方法与Q-Q图文章目录蒙特卡洛方法与Q-Q图蒙特卡洛方法蒙特卡洛的定义和基本步骤一些常用的概率论相关函数使用蒙特卡洛验证大数定理Q-Q图Q-Q图的定义及用途importnumpyasnpfromnumpy.linalgimportinv,eigimportmatplotlib.pyplotaspltimportpandasaspdfromscipy.statsimportnorm蒙特卡洛方
机器学习实战1-基础运用（2022/10/11）点灯的棉羊机器学习Jupyter笔记机器学习 python numpy
机器学习实战1-基础运用文章目录机器学习实战1-基础运用numpy的简单运用生成矩阵和矩阵的简单操作用pandas库读取、保存csv数据文件read_csv()函数及读入的数据处理to_csv()保存数据matplotlib.pyplot库绘图的使用条形图的绘制箱型图的绘制分位数（Quantile）分位点/四分位数分位数与箱型图`boxplot()`函数绘制交叉报表热力图plt绘图基础import
机器学习实战Jupyter笔记专栏汇总点灯的棉羊机器学习Jupyter笔记机器学习 jupyter 人工智能
机器学习实战Jupter笔记开始博客学校开始的一门机器学习的课程，于是使用jupyter写这门课的作业，顺便将其完善为笔记发表为这个专栏的博客，并将专栏博客链接汇总到这里。由于是刚开始学习机器学习方面的内容，如有错误的地方，希望能有大佬能帮忙指正。笔记1机器学习实战1-基础运用种一棵树最好的时间–是十年前，其次是现在
朴素贝叶斯算法 YuanDaima2048 机器学习算法学习算法机器学习人工智能深度学习 python sklearn
朴素贝叶斯算法一、基本概念二、算法及代码应用朴素贝叶斯NB算法分类算法区别其他机器学习算法：机器学习实战工具安装和使用一、基本概念朴素贝叶斯（NB）是一种基于贝叶斯定理与特征条件独立假设的分类算法。它被广泛应用于文本分类、垃圾邮件过滤等领域。朴素贝叶斯算法简单易懂，其核心思想是假设在给定目标值时，各个属性之间相互独立。在实际应用中，朴素贝叶斯算法在垃圾邮件过滤中表现出色。它不仅准确率高，而且速度快
【机器学习实战】大数据与MapReduce 吵吵人
当运算需求超出了当前资源的运算能力，一、可以考虑购买更好的机器；二、可以将计算转换成并行作业，MapReduce就提供了这种方案的一个具体实施框架。MapReduce：分布式计算的框架MapReduce是一个软件框架，可以将单个计算工作分配给多台计算机执行。工作流程包括map和reduce阶段。第一阶段，输入数据被切片分发到节点上，各个节点对本地数据进行处理对应的运算代码叫做mapper。第二阶段
[培训-Python机器学习]04-Git的使用和规范乱码奇糟软件开发 git
参考书Python机器学习实战作者裔隽张怿檬张目清出版社科学技术文献出版社难度入门安排计划：本章30分钟；作业：上网查阅Linus开发Git的背景；分析所在的开发团队所用的协作开发流程是什么？总结出Git使用和Git流程中遇到过的3个问题，发给大家讨论。非常有意思：2005年，由Linux的创始人LinusTorvalds开发；临危赴命，用时2周。分布式、本地管理、分支管理、提交机制Github、
[培训-Python机器学习]02-使用conda管理环境和包乱码奇糟软件开发 python conda
参考书Python机器学习实战作者裔隽张怿檬张目清出版社科学技术文献出版社难度入门安排计划：本章30分钟；作业：培训后实践本章的各种操作；结果：以Python3.10创建开发虚拟环境；再创建一个Python3.7版本以下的虚拟环境用来调试兼容性以前培训过venv，本次培训来说一说conda。conda其实可理解为：venv+pip，它的主要功能包括：环境管理：创建多个隔离的Python运行环境，每
机器学习（machine learning）大合集 AI信仰者
1、线性分类器怎么理解呢？我们可以把此分类器理解为线性空间的划分，最简单的，在二维空间上，通过直线的划分。第二个理解可以理解为模板匹配，W的每一行可以看做是其中一个类别的模板。每类得分，实际上是像素点和模板匹配度。模板匹配的方式是内积计算。2、机器学习实战之AdaBoost算法boosting算法系列的基本思想，如下图：adaBoost分类器就是一种元算法分类器，adaBoost分类器利用同一种基
机器学习实战朴素贝叶斯分类器 shenny_
基于概率论的分类方法：朴素贝叶斯我的微信公众号：s406205391;欢迎大家一起学习，一起进步！！！k-近邻算法和决策树会给出“该数据属于哪一类”的明确回答。不过，分类器有时会产生错误结果，这是可以要求分类器给出一个最优的类别的猜测结果，同事给出这个猜测的概率估计值。朴素贝叶斯就是一个概率分类器。我们称之为“朴素”，是因为整个形式化的过程只做最原始、最简单的假设。朴素贝叶斯的优点：在数据较少的情
《机器学习实战》笔记（十三）：Ch13 - 利用PCA来简化数据 Lornatang
第13章利用PCA来简化数据(代码)降维技术降维的意思是能够用一组个数为d的向量zi来代表个数为D的向量xi所包含的有用信息，其中d
Python实现时间序列分析马尔可夫切换自回归模型(MarkovAutoregression算法)项目实战胖哥真不错机器学习 python python 机器学习时间序列分析马尔可夫切换自回归模型项目实战
说明：这是一个机器学习实战项目（附带数据+代码+文档+视频讲解），如需数据+代码+文档+视频讲解可以直接到文章最后获取。1.项目背景时间序列分析中的马尔可夫切换自回归模型（MarkovSwitchingAutoregressionModel，简称MSAR或MarkovAutoregression算法）是一种混合了自回归模型（AutoregressiveModel,AR）和马尔可夫链（MarkovC
Python实现时间序列分析马尔可夫切换动态回归模型(MarkovRegression算法)项目实战胖哥真不错机器学习 python python 机器学习时间序列分析马尔可夫切换动态回归模型项目实战
说明：这是一个机器学习实战项目（附带数据+代码+文档+视频讲解），如需数据+代码+文档+视频讲解可以直接到文章最后获取。1.项目背景时间序列分析中的马尔可夫切换动态回归模型（MarkovSwitchingDynamicRegressionModel，MSDRM或简称为MarkovRegression算法）是一种用于处理具有非平稳性和隐藏状态依赖性的时序数据的方法。在该模型中，数据生成过程被认为是在
Python实现时间序列分析季节性自回归综合移动平均外生回归模型(SARIMAX算法)项目实战胖哥真不错机器学习 python python 时间序列分析季节性自回归综合移动平均外生回归模型 SARIMAX 项目实战
说明：这是一个机器学习实战项目（附带数据+代码+文档+视频讲解），如需数据+代码+文档+视频讲解可以直接到文章最后获取。1.项目背景时间序列分析中的季节性自回归综合移动平均外生回归模型（SeasonalAutoregressiveIntegratedMovingAveragewitheXogenousregressors,SARIMAX）是一种统计建模技术，用于分析和预测具有季节性、趋势以及可能受
Python实现时间序列分析AR定阶自回归模型(ar_select_order算法)项目实战胖哥真不错机器学习 python python 机器学习时间序列分析AR定阶自回归模型 ar_select_order 项目实战
说明：这是一个机器学习实战项目（附带数据+代码+文档+视频讲解），如需数据+代码+文档+视频讲解可以直接到文章最后获取。1.项目背景时间序列分析中，AR定阶自回归模型（ARorderselection）是指确定自回归模型（AutoRegressiveModel,AR模型）的阶数p的过程。在AR(p)模型中，当前的时间序列值被表示为过去p个时期的线性组合加上一个误差项。ar_select_order
python机器学习实战|机器学习入门笔记3-Pandas基础知识小赵同学871 机器学习实战入门笔记 python 机器学习 pandas
文章目录1.Pandas介绍2.案例知识点2.1创建DataFrame2.2创建日期3.DataFrame介绍3.1DataFrame属性3.2DataFrame设置索引3.3基本数据操作3.4DataFrame运算1.Pandas介绍开源的数据挖掘库，用于数据探索，封装了matplotlib，numpy2.案例知识点2.1创建DataFramepd.DataFrame(ndarray,index
Python实现离散选择概率模型(Probit算法)项目实战胖哥真不错机器学习 python python 离散选择概率模型 Probit算法机器学习项目实战
说明：这是一个机器学习实战项目（附带数据+代码+文档+视频讲解），如需数据+代码+文档+视频讲解可以直接到文章最后获取。1.项目背景Probit模型是经过Logit模型的形式经过变形后得到的，Probit模型假设与标准正态分布的概率分布函数相似。本项目通过Probit算法来构建概率模型。2.数据获取本次建模数据来源于网络(本项目撰写人整理而成)，数据项统计如下：编号变量名称描述1x12x23x34
机器学习实战 K-近邻算法今昔何夕丶
K-近邻算法优点：精度高、对异常值不敏感、无数据输入假定缺点：计算复杂高、空间复杂度高适用数据范围：数值型和标称型一般流程收集数据：可以使用任何方法准备数据：距离计算所需要的数值，最好是结构化的数据结构分析数据：可以使用任何方法训练算法：此步骤不适用于K-近邻算法测试算法：计算错误率使用算法：首先需要输入样本数据和结构化的输出结果，然后运行K-近邻算法判定输入数据分别属于哪个分类，最后应用对计算出
Python实现稳健线性回归模型(rlm算法)项目实战胖哥真不错机器学习 python python 机器学习稳健线性回归模型 rlm算法项目实战
说明：这是一个机器学习实战项目（附带数据+代码+文档+视频讲解），如需数据+代码+文档+视频讲解可以直接到文章最后获取。1.项目背景稳健回归可以用在任何使用最小二乘回归的情况下。在拟合最小二乘回归时，我们可能会发现一些异常值或高杠杆数据点。已经确定这些数据点不是数据输入错误，也不是来自另一个群落。所以我们没有令人信服的理由将它们排除在分析之外。稳健回归可能是一种好的策略，它是在将这些点完全从分析中
机器学习实战学习记录（github） monkeyhlj 学习
机器学习实战学习记录（github）可见我的github：https://github.com/monkeyhlj/machine_learning_bymyself刚刚建好，后面的学习记录会一直在这个仓库里面更新。推荐参考资料：https://www.zhihu.com/column/c_1242508311053963264
【机器学习实战】决策树吵吵人
算法思路在构造决策树时，第一个需要解决的问题就是，如何确定出哪个特征在划分数据分类是起决定性作用，或者说使用哪个特征分类能实现最好的分类效果。这样，为了找到决定性的特征，划分得到最好的结果，我们就需要评估每个特征。当找到最优特征后，依此特征，数据集就被划分为几个数据子集，这些数据自己会分布在该决策点的所有分支中。此时，如果某个分支下的数据属于同一类型，则该分支下的数据分类已经完成，无需进行下一步的
Python实现基于多元线性回归模型进行统计学相互作用和方差分析(anova算法)项目实战胖哥真不错机器学习 python 线性回归人工智能机器学习 python 相互作用方差分析 anova算法
说明：这是一个机器学习实战项目（附带数据+代码+文档+视频讲解），如需数据+代码+文档+视频讲解可以直接到文章最后获取。1.项目背景多元线性回归模型（MultipleLinearRegressionModel）是一种统计学方法，用于研究一个或多个自变量（predictors）与因变量（dependentvariable）之间的关系。在模型中，因变量的值通过一个线性函数来预测，该函数包含了自变量的系
Python实现基于广义线性回归模型进行Meta分析(meta_analysis算法)项目实战胖哥真不错机器学习 python 线性回归 python 机器学习广义线性回归模型 Meta分析 meta_analysis算法项目实战
说明：这是一个机器学习实战项目（附带数据+代码+文档+视频讲解），如需数据+代码+文档+视频讲解可以直接到文章最后获取。1.项目背景对于广义线性回归模型在Meta分析中的应用概念，可能是将其用于处理非正态分布或非线性关系的数据，例如：1.当原始研究的结果数据不是连续型且服从正态分布，而是二项分布（如成功率）、泊松分布（如发病率）或其他分布时，可以通过GLM设定适当的链接函数和分布族来适应。2.在进
Python实现GEE嵌套协方差结构仿真模型(GEE算法)项目实战胖哥真不错机器学习 python python 机器学习 GEE嵌套协方差结构仿真模型 GEE算法项目实战
说明：这是一个机器学习实战项目（附带数据+代码+文档+视频讲解），如需数据+代码+文档+视频讲解可以直接到文章最后获取。1.项目背景广义估计方程（GeneralizedEstimatingEquations,GEE）是一种用于分析具有重复测量或者集群数据的统计方法。在社会学、医学、生物学等多个领域，研究对象的数据往往存在嵌套或群聚结构，即个体的数据不是独立的，而是隶属于某个群体或层级结构中。GEE
Python实现M-Estimators稳健线性回归模型(RLM算法)项目实战胖哥真不错机器学习 python python 机器学习 M-Estimators 稳健线性回归模型 RLM算法
说明：这是一个机器学习实战项目（附带数据+代码+文档+视频讲解），如需数据+代码+文档+视频讲解可以直接到文章最后获取。1.项目背景M-Estimators是稳健统计估计中的一个重要概念，它们在处理含有异常值、离群点或者影响点的数据时特别有用。在稳健线性回归（RobustLinearRegression,RLM）模型中，M-Estimators用于替代普通最小二乘法（OLS），以减少这些极端观测值
机器学习——python训练RNN模型实战（傻瓜式教学，小学生都可以学会）代码开源苏苏不是叔机器学习 python rnn
机器学习实战目录第一章python训练线性模型实战第二章python训练决策树模型实战第三章python训练神经网络模型实战第四章python训练支持向量机模型实战第五章python训练贝叶斯分类器模型实战第六章python训练集成学习模型实战第七章python训练聚类模型实战第八章python训练KNN模型实战第九章python训练CNN模型实战第十章python训练RNN模型实战......(
机器学习——python训练决策树模型实战（傻瓜式教学，小学生都可以学会）苏苏不是叔机器学习 python 决策树
机器学习——python训练决策树模型实战目录机器学习——python训练决策树模型实战机器学习实战目录训练一个决策树模型需要经过以下步骤：1.下载数据集2.数据预处理3.加载数据集4.准备训练数据5.创建模型6.训练模型7.测试模型参考资料机器学习实战目录第一章python训练线性模型实战第二章python训练决策树模型实战第三章python训练神经网络模型实战第四章python训练支持向量机模
对股票分析时要注意哪些主要因素？会飞的奇葩猪股票分析云掌股吧
　　众所周知，对散户投资者来说，股票技术分析是应战股市的核心武器，想学好股票的技术分析一定要知道哪些是重点学习的，其实非常简单，我们只要记住三个要素：成交量、价格趋势、振荡指标。一、成交量　　大盘的成交量状态。成交量大说明市场的获利机会较多，成交量小说明市场的获利机会较少。当沪市的成交量超过150亿时是强市市场状态，运用技术找综合买点较准；
【Scala十八】视图界定与上下文界定 bit1129 scala
Context Bound，上下文界定，是Scala为隐式参数引入的一种语法糖，使得隐式转换的编码更加简洁。隐式参数首先引入一个泛型函数max，用于取a和b的最大值 def max[T](a: T, b: T) = { if (a > b) a else b } 因为T是未知类型，只有运行时才会代入真正的类型，因此调用a >
C语言的分支——Object-C程序设计阅读有感 darkblue086 apple c 框架 cocoa
自从1972年贝尔实验室Dennis Ritchie开发了C语言，C语言已经有了很多版本和实现，从Borland到microsoft还是GNU、Apple都提供了不同时代的多种选择，我们知道C语言是基于Thompson开发的B语言的，Object-C是以SmallTalk-80为基础的。和C++不同的是，Object C并不是C的超集，因为有很多特性与C是不同的。 Object-C程序设计这本书
去除浏览器对表单值的记忆周凡杨 html 记忆 autocomplete form 浏览
&n
java的树形通讯录 g21121 java
最近用到企业通讯录，虽然以前也开发过，但是用的是jsf，拼成的树形，及其笨重和难维护。后来就想到直接生成json格式字符串，页面上也好展现。 // 首先取出每个部门的联系人 for (int i = 0; i < depList.size(); i++) { List<Contacts> list = getContactList(depList.get(i
Nginx安装部署 510888780 nginx linux
Nginx ("engine x") 是一个高性能的 HTTP 和反向代理服务器，也是一个 IMAP/POP3/SMTP 代理服务器。 Nginx 是由 Igor Sysoev 为俄罗斯访问量第二的 Rambler.ru 站点开发的，第一个公开版本0.1.0发布于2004年10月4日。其将源代码以类BSD许可证的形式发布，因它的稳定性、丰富的功能集、示例配置文件和低系统资源
java servelet异步处理请求墙头上一根草ｊａｖａ异步返回ｓｅｒｖｌｅｔ
servlet3.0以后支持异步处理请求，具体是使用AsyncContext ，包装httpservletRequest以及httpservletResponse具有异步的功能， final AsyncContext ac = request.startAsync(request, response); ac.s
我的spring学习笔记8-Spring中Bean的实例化 aijuans Spring 3
在Spring中要实例化一个Bean有几种方法： 1、最常用的（普通方法） <bean id="myBean" class="www.6e6.org.MyBean" /> 使用这样方法，按Spring就会使用Bean的默认构造方法，也就是把没有参数的构造方法来建立Bean实例。（有构造方法的下个文细说） 2、还
为Mysql创建最优的索引 annan211 mysql 索引
索引对于良好的性能非常关键，尤其是当数据规模越来越大的时候，索引的对性能的影响越发重要。索引经常会被误解甚至忽略，而且经常被糟糕的设计。索引优化应该是对查询性能优化最有效的手段了，索引能够轻易将查询性能提高几个数量级，最优的索引会比较好的索引性能要好2个数量级。 1 索引的类型 (1) B-Tree 不出意外，这里提到的索引都是指 B-
日期函数百合不是茶 oracle sql 日期函数查询
ORACLE日期时间函数大全 TO_DATE格式(以时间:2007-11-02 13:45:25为例) Year: yy two digits 两位年显示值:07 yyy three digits 三位年显示值:007
线程优先级 bijian1013 java thread 多线程 java多线程
多线程运行时需要定义线程运行的先后顺序。线程优先级是用数字表示，数字越大线程优先级越高，取值在1到10，默认优先级为5。实例： package com.bijian.study; /** * 因为在代码段当中把线程B的优先级设置高于线程A,所以运行结果先执行线程B的run()方法后再执行线程A的run()方法 * 但在实际中，JAVA的优先级不准，强烈不建议用此方法来控制执
适配器模式和代理模式的区别 bijian1013 java 设计模式
一.简介适配器模式：适配器模式（英语：adapter pattern）有时候也称包装样式或者包装。将一个类的接口转接成用户所期待的。一个适配使得因接口不兼容而不能在一起工作的类工作在一起，做法是将类别自己的接口包裹在一个已存在的类中。 &nbs
【持久化框架MyBatis3三】MyBatis3 SQL映射配置文件 bit1129 Mybatis3
SQL映射配置文件一方面类似于Hibernate的映射配置文件，通过定义实体与关系表的列之间的对应关系。另一方面使用<select>,<insert>,<delete>，<update>元素定义增删改查的SQL语句，这些元素包含三方面内容 1. 要执行的SQL语句 2. SQL语句的入参，比如查询条件 3. SQL语句的返回结果
oracle大数据表复制备份个人经验 bitcarter oracle 大表备份大表数据复制
前提：数据库仓库A（就拿oracle11g为例）中有两个用户user1和user2,现在有user1中有表ldm_table1,且表ldm_table1有数据5千万以上，ldm_table1中的数据是从其他库B（数据源）中抽取过来的，前期业务理解不够或者需求有变，数据有变动需要重新从B中抽取数据到A库表ldm_table1中。
HTTP加速器varnish安装小记 ronin47 http varnish 加速
上午共享的那个varnish安装手册，个人看了下，有点不知所云，好吧~看来还是先安装玩玩！苦逼公司服务器没法连外网，不能用什么wget或yum命令直接下载安装，每每看到别人博客贴出的在线安装代码时，总有一股羡慕嫉妒“恨”冒了出来。。。好吧，既然没法上外网，那只能麻烦点通过下载源码来编译安装了！ Varnish 3.0.4下载地址： http://repo.varnish-cache.org/
java-73-输入一个字符串，输出该字符串中对称的子字符串的最大长度 bylijinnan java
public class LongestSymmtricalLength { /* * Q75题目：输入一个字符串，输出该字符串中对称的子字符串的最大长度。 * 比如输入字符串“google”，由于该字符串里最长的对称子字符串是“goog”，因此输出4。 */ public static void main(String[] args) { Str
学习编程的一点感想 Cb123456 编程感想 Gis
写点感想，总结一些，也顺便激励一些自己.现在就是复习阶段，也做做项目. 本专业是GIS专业，当初觉得本专业太水，靠这个会活不下去的，所以就报了培训班。学习的时候，进入状态很慢，而且当初进去的时候，已经上到Java高级阶段了，所以.....，呵呵，之后有点感觉了，不过，还是不好好写代码，还眼高手低的，有
[能源与安全]美国与中国 comsci 能源
现在有一个局面：地球上的石油只剩下N桶，这些油只够让中国和美国这两个国家中的一个顺利过渡到宇宙时代，但是如果这两个国家为争夺这些石油而发生战争，其结果是两个国家都无法平稳过渡到宇宙时代。。。。而且在战争中，剩下的石油也会被快速消耗在战争中，结果是两败俱伤。。。在这个大
SEMI-JOIN执行计划突然变成HASH JOIN了的原因分析 cwqcwqmax9 oracle
甲说： A B两个表总数据量都很大，在百万以上。 idx1 idx2字段表示是索引字段 A B 两表上都有 col1字段表示普通字段 select xxx from A where A.idx1 between mmm and nnn and exists (select 1 from B where B.idx2 =
SpringMVC-ajax返回值乱码解决方案 dashuaifu Ajax springMVC response 中文乱码
SpringMVC-ajax返回值乱码解决方案一：（自己总结，测试过可行） ajax返回如果含有中文汉字，则使用：（如下例：） @RequestMapping(value="/xxx.do") public @ResponseBody void getPunishReasonB
Linux系统中查看日志的常用命令 dcj3sjt126com OS
因为在日常的工作中，出问题的时候查看日志是每个管理员的习惯，作为初学者，为了以后的需要，我今天将下面这些查看命令共享给各位 cat tail -f 日志文件说明 /var/log/message 系统启动后的信息和错误日志，是Red Hat Linux中最常用的日志之一 /var/log/secure 与安全相关的日志信息 /var/log/maillog 与邮件相关的日志信
[应用结构]应用 dcj3sjt126com PHP yii2
应用主体应用主体是管理 Yii 应用系统整体结构和生命周期的对象。每个Yii应用系统只能包含一个应用主体，应用主体在入口脚本中创建并能通过表达式 \Yii::$app 全局范围内访问。补充: 当我们说"一个应用"，它可能是一个应用主体对象，也可能是一个应用系统，是根据上下文来决定[译：中文为避免歧义，Application翻译为应
assertThat用法 eksliang JUnit assertThat
junit4.0 assertThat用法一般匹配符1、assertThat( testedNumber, allOf( greaterThan(8), lessThan(16) ) ); 注释： allOf匹配符表明如果接下来的所有条件必须都成立测试才通过，相当于“与”（&&） 2、assertThat( testedNumber, anyOf( g
android点滴2 gundumw100 应用服务器 android 网络应用 OS HTC
如何让Drawable绕着中心旋转？ Animation a = new RotateAnimation(0.0f, 360.0f, Animation.RELATIVE_TO_SELF, 0.5f, Animation.RELATIVE_TO_SELF,0.5f); a.setRepeatCount(-1); a.setDuration(1000); 如何控制Andro
超简洁的CSS下拉菜单 ini html Web 工作 html5 css
效果体验：http://hovertree.com/texiao/css/3.htmHTML文件： <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml"> <head> <title>简洁的HTML+CSS下拉菜单-HoverTree</title>
kafka consumer防止数据丢失 kane_xie kafka offset commit
kafka最初是被LinkedIn设计用来处理log的分布式消息系统，因此它的着眼点不在数据的安全性（log偶尔丢几条无所谓），换句话说kafka并不能完全保证数据不丢失。尽管kafka官网声称能够保证at-least-once，但如果consumer进程数小于partition_num，这个结论不一定成立。考虑这样一个case，partiton_num=2
@Repository、@Service、@Controller 和 @Component mhtbbx DAO spring bean prototype
@Repository、@Service、@Controller 和 @Component 将类标识为Bean Spring 自 2.0 版本开始，陆续引入了一些注解用于简化 Spring 的开发。@Repository注解便属于最先引入的一批，它用于将数据访问层 (DAO 层 ) 的类标识为 Spring Bean。具体只需将该注解标注在 DAO类上即可。同时，为了让 Spring 能够扫描类
java 多线程高并发读写控制误区 qifeifei java thread
先看一下下面的错误代码，对写加了synchronized控制，保证了写的安全，但是问题在哪里呢？ public class testTh7 { private String data; public String read(){ System.out.println(Thread.currentThread().getName() + "read data "
mongodb replica set(副本集)设置步骤 tcrct java mongodb
网上已经有一大堆的设置步骤的了，根据我遇到的问题，整理一下，如下：首先先去下载一个mongodb最新版，目前最新版应该是2.6 cd /usr/local/bin wget http://fastdl.mongodb.org/linux/mongodb-linux-x86_64-2.6.0.tgz tar -zxvf mongodb-linux-x86_64-2.6.0.t
rust学习笔记 wudixiaotie 学习笔记
1.rust里绑定变量是let，默认绑定了的变量是不可更改的，所以如果想让变量可变就要加上mut。 let x = 1; let mut y = 2; 2.match 相当于erlang中的case，但是case的每一项后都是分号，但是rust的match却是逗号。 3.match 的每一项最后都要加逗号，但是最后一项不加也不会报错，所有结尾加逗号的用法都是类似。 4.每个语句结尾都要加分