-
2020-12-10 01:53:49
import pandas as pd
from sklearn.naive_bayes import GaussianNB
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score
from sklearn import datasets
iris=datasets.load_iris()
print(iris)
{'DESCR': '.. _iris_dataset:\n\nIris plants dataset\n--------------------\n\n**Data Set Characteristics:**\n\n :Number of Instances: 150 (50 in each of three classes)\n :Number of Attributes: 4 numeric, predictive attributes and the class\n :Attribute Information:\n - sepal length in cm\n - sepal width in cm\n - petal length in cm\n - petal width in cm\n - class:\n - Iris-Setosa\n - Iris-Versicolour\n - Iris-Virginica\n \n :Summary Statistics:\n\n ============== ==== ==== ======= ===== ====================\n Min Max Mean SD Class Correlation\n ============== ==== ==== ======= ===== ====================\n sepal length: 4.3 7.9 5.84 0.83 0.7826\n sepal width: 2.0 4.4 3.05 0.43 -0.4194\n petal length: 1.0 6.9 3.76 1.76 0.9490 (high!)\n petal width: 0.1 2.5 1.20 0.76 0.9565 (high!)\n ============== ==== ==== ======= ===== ====================\n\n :Missing Attribute Values: None\n :Class Distribution: 33.3% for each of 3 classes.\n :Creator: R.A. Fisher\n :Donor: Michael Marshall (MARSHALL%PLU@io.arc.nasa.gov)\n :Date: July, 1988\n\nThe famous Iris database, first used by Sir R.A. Fisher. The dataset is taken\nfrom Fisher\'s paper. Note that it\'s the same as in R, but not as in the UCI\nMachine Learning Repository, which has two wrong data points.\n\nThis is perhaps the best known database to be found in the\npattern recognition literature. Fisher\'s paper is a classic in the field and\nis referenced frequently to this day. (See Duda & Hart, for example.) The\ndata set contains 3 classes of 50 instances each, where each class refers to a\ntype of iris plant. One class is linearly separable from the other 2; the\nlatter are NOT linearly separable from each other.\n\n.. topic:: References\n\n - Fisher, R.A. "The use of multiple measurements in taxonomic problems"\n Annual Eugenics, 7, Part II, 179-188 (1936); also in "Contributions to\n Mathematical Statistics" (John Wiley, NY, 1950).\n - Duda, R.O., & Hart, P.E. (1973) Pattern Classification and Scene Analysis.\n (Q327.D83) John Wiley & Sons. ISBN 0-471-22361-1. See page 218.\n - Dasarathy, B.V. (1980) "Nosing Around the Neighborhood: A New System\n Structure and Classification Rule for Recognition in Partially Exposed\n Environments". IEEE Transactions on Pattern Analysis and Machine\n Intelligence, Vol. PAMI-2, No. 1, 67-71.\n - Gates, G.W. (1972) "The Reduced Nearest Neighbor Rule". IEEE Transactions\n on Information Theory, May 1972, 431-433.\n - See also: 1988 MLC Proceedings, 54-64. Cheeseman et al"s AUTOCLASS II\n conceptual clustering system finds 3 classes in the data.\n - Many, many more ...', 'filename': 'e:\\application\\python\\lib\\site-packages\\sklearn\\datasets\\data\\iris.csv', 'data': array([[5.1, 3.5, 1.4, 0.2],
[4.9, 3. , 1.4, 0.2],
[4.7, 3.2, 1.3, 0.2],
[4.6, 3.1, 1.5, 0.2],
[5. , 3.6, 1.4, 0.2],
[5.4, 3.9, 1.7, 0.4],
[4.6, 3.4, 1.4, 0.3],
[5. , 3.4, 1.5, 0.2],
[4.4, 2.9, 1.4, 0.2],
[4.9, 3.1, 1.5, 0.1],
[5.4, 3.7, 1.5, 0.2],
[4.8, 3.4, 1.6, 0.2],
[4.8, 3. , 1.4, 0.1],
[4.3, 3. , 1.1, 0.1],
[5.8, 4. , 1.2, 0.2],
[5.7, 4.4, 1.5, 0.4],
[5.4, 3.9, 1.3, 0.4],
[5.1, 3.5, 1.4, 0.3],
[5.7, 3.8, 1.7, 0.3],
[5.1, 3.8, 1.5, 0.3],
[5.4, 3.4, 1.7, 0.2],
[5.1, 3.7, 1.5, 0.4],
[4.6, 3.6, 1. , 0.2],
[5.1, 3.3, 1.7, 0.5],
[4.8, 3.4, 1.9, 0.2],
[5. , 3. , 1.6, 0.2],
[5. , 3.4, 1.6, 0.4],
[5.2, 3.5, 1.5, 0.2],
[5.2, 3.4, 1.4, 0.2],
[4.7, 3.2, 1.6, 0.2],
[4.8, 3.1, 1.6, 0.2],
[5.4, 3.4, 1.5, 0.4],
[5.2, 4.1, 1.5, 0.1],
[5.5, 4.2, 1.4, 0.2],
[4.9, 3.1, 1.5, 0.2],
[5. , 3.2, 1.2, 0.2],
[5.5, 3.5, 1.3, 0.2],
[4.9, 3.6, 1.4, 0.1],
[4.4, 3. , 1.3, 0.2],
[5.1, 3.4, 1.5, 0.2],
[5. , 3.5, 1.3, 0.3],
[4.5, 2.3, 1.3, 0.3],
[4.4, 3.2, 1.3, 0.2],
[5. , 3.5, 1.6, 0.6],
[5.1, 3.8, 1.9, 0.4],
[4.8, 3. , 1.4, 0.3],
[5.1, 3.8, 1.6, 0.2],
[4.6, 3.2, 1.4, 0.2],
[5.3, 3.7, 1.5, 0.2],
[5. , 3.3, 1.4, 0.2],
[7. , 3.2, 4.7, 1.4],
[6.4, 3.2, 4.5, 1.5],
[6.9, 3.1, 4.9, 1.5],
[5.5, 2.3, 4. , 1.3],
[6.5, 2.8, 4.6, 1.5],
[5.7, 2.8, 4.5, 1.3],
[6.3, 3.3, 4.7, 1.6],
[4.9, 2.4, 3.3, 1. ],
[6.6, 2.9, 4.6, 1.3],
[5.2, 2.7, 3.9, 1.4],
[5. , 2. , 3.5, 1. ],
[5.9, 3. , 4.2, 1.5],
[6. , 2.2, 4. , 1. ],
[6.1, 2.9, 4.7, 1.4],
[5.6, 2.9, 3.6, 1.3],
[6.7, 3.1, 4.4, 1.4],
[5.6, 3. , 4.5, 1.5],
[5.8, 2.7, 4.1, 1. ],
[6.2, 2.2, 4.5, 1.5],
[5.6, 2.5, 3.9, 1.1],
[5.9, 3.2, 4.8, 1.8],
[6.1, 2.8, 4. , 1.3],
[6.3, 2.5, 4.9, 1.5],
[6.1, 2.8, 4.7, 1.2],
[6.4, 2.9, 4.3, 1.3],
[6.6, 3. , 4.4, 1.4],
[6.8, 2.8, 4.8, 1.4],
[6.7, 3. , 5. , 1.7],
[6. , 2.9, 4.5, 1.5],
[5.7, 2.6, 3.5, 1. ],
[5.5, 2.4, 3.8, 1.1],
[5.5, 2.4, 3.7, 1. ],
[5.8, 2.7, 3.9, 1.2],
[6. , 2.7, 5.1, 1.6],
[5.4, 3. , 4.5, 1.5],
[6. , 3.4, 4.5, 1.6],
[6.7, 3.1, 4.7, 1.5],
[6.3, 2.3, 4.4, 1.3],
[5.6, 3. , 4.1, 1.3],
[5.5, 2.5, 4. , 1.3],
[5.5, 2.6, 4.4, 1.2],
[6.1, 3. , 4.6, 1.4],
[5.8, 2.6, 4. , 1.2],
[5. , 2.3, 3.3, 1. ],
[5.6, 2.7, 4.2, 1.3],
[5.7, 3. , 4.2, 1.2],
[5.7, 2.9, 4.2, 1.3],
[6.2, 2.9, 4.3, 1.3],
[5.1, 2.5, 3. , 1.1],
[5.7, 2.8, 4.1, 1.3],
[6.3, 3.3, 6. , 2.5],
[5.8, 2.7, 5.1, 1.9],
[7.1, 3. , 5.9, 2.1],
[6.3, 2.9, 5.6, 1.8],
[6.5, 3. , 5.8, 2.2],
[7.6, 3. , 6.6, 2.1],
[4.9, 2.5, 4.5, 1.7],
[7.3, 2.9, 6.3, 1.8],
[6.7, 2.5, 5.8, 1.8],
[7.2, 3.6, 6.1, 2.5],
[6.5, 3.2, 5.1, 2. ],
[6.4, 2.7, 5.3, 1.9],
[6.8, 3. , 5.5, 2.1],
[5.7, 2.5, 5. , 2. ],
[5.8, 2.8, 5.1, 2.4],
[6.4, 3.2, 5.3, 2.3],
[6.5, 3. , 5.5, 1.8],
[7.7, 3.8, 6.7, 2.2],
[7.7, 2.6, 6.9, 2.3],
[6. , 2.2, 5. , 1.5],
[6.9, 3.2, 5.7, 2.3],
[5.6, 2.8, 4.9, 2. ],
[7.7, 2.8, 6.7, 2. ],
[6.3, 2.7, 4.9, 1.8],
[6.7, 3.3, 5.7, 2.1],
[7.2, 3.2, 6. , 1.8],
[6.2, 2.8, 4.8, 1.8],
[6.1, 3. , 4.9, 1.8],
[6.4, 2.8, 5.6, 2.1],
[7.2, 3. , 5.8, 1.6],
[7.4, 2.8, 6.1, 1.9],
[7.9, 3.8, 6.4, 2. ],
[6.4, 2.8, 5.6, 2.2],
[6.3, 2.8, 5.1, 1.5],
[6.1, 2.6, 5.6, 1.4],
[7.7, 3. , 6.1, 2.3],
[6.3, 3.4, 5.6, 2.4],
[6.4, 3.1, 5.5, 1.8],
[6. , 3. , 4.8, 1.8],
[6.9, 3.1, 5.4, 2.1],
[6.7, 3.1, 5.6, 2.4],
[6.9, 3.1, 5.1, 2.3],
[5.8, 2.7, 5.1, 1.9],
[6.8, 3.2, 5.9, 2.3],
[6.7, 3.3, 5.7, 2.5],
[6.7, 3. , 5.2, 2.3],
[6.3, 2.5, 5. , 1.9],
[6.5, 3. , 5.2, 2. ],
[6.2, 3.4, 5.4, 2.3],
[5.9, 3. , 5.1, 1.8]]), 'feature_names': ['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)'], 'target': array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 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, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]), 'target_names': array(['setosa', 'versicolor', 'virginica'], dtype='
X_train,Xtest,y_train,y_test=train_test_split(iris.data,iris.target,
random_state=12)
print(X_train.shape)
print(Xtest.shape)
(112, 4)
(38, 4)
clf=GaussianNB()
clf.fit(X_train,y_train)
GaussianNB(priors=None, var_smoothing=1e-09)
clf.predict(Xtest)
array([0, 2, 0, 1, 2, 2, 2, 0, 2, 0, 1, 0, 0, 0, 1, 2, 2, 1, 0, 1, 0, 1,
2, 1, 0, 2, 2, 1, 0, 0, 0, 1, 2, 0, 2, 0, 1, 1])
clf.predict_proba(Xtest)
array([[1.00000000e+000, 2.32926069e-017, 1.81656357e-023],
[4.28952299e-154, 2.48576754e-002, 9.75142325e-001],
[1.00000000e+000, 7.45528845e-018, 3.79800436e-024],
[3.59748710e-076, 9.99751806e-001, 2.48194200e-004],
[2.20411871e-239, 4.45798016e-009, 9.99999996e-001],
[1.23795145e-173, 1.95814902e-003, 9.98041851e-001],
[2.45866589e-206, 2.34481513e-007, 9.99999766e-001],
[1.00000000e+000, 2.61810906e-017, 2.67446831e-023],
[3.07448595e-259, 9.07196639e-011, 1.00000000e+000],
[1.00000000e+000, 1.14549667e-010, 3.00314173e-017],
[1.64566141e-101, 9.87428016e-001, 1.25719837e-002],
[1.00000000e+000, 5.62770009e-016, 8.77233124e-022],
[1.00000000e+000, 9.78098062e-014, 4.81247272e-020],
[1.00000000e+000, 3.96616431e-015, 3.17162008e-021],
[2.58159395e-110, 7.85918892e-001, 2.14081108e-001],
[8.01004975e-208, 8.36611920e-006, 9.99991634e-001],
[2.27845999e-193, 5.52863568e-004, 9.99447136e-001],
[2.52133012e-090, 9.94597495e-001, 5.40250471e-003],
[1.00000000e+000, 4.06675976e-017, 2.53312064e-023],
[3.29537129e-123, 9.22312452e-001, 7.76875484e-002],
[1.00000000e+000, 4.66765440e-017, 1.99662820e-023],
[7.54708431e-074, 9.99690656e-001, 3.09343577e-004],
[6.27117035e-136, 1.83265786e-001, 8.16734214e-001],
[4.68960290e-103, 9.82756006e-001, 1.72439943e-002],
[1.00000000e+000, 2.15636250e-014, 2.25086772e-020],
[5.92924136e-199, 5.41122729e-007, 9.99999459e-001],
[4.07679795e-141, 7.38689632e-002, 9.26131037e-001],
[2.77929930e-083, 9.99806458e-001, 1.93541791e-004],
[1.00000000e+000, 4.48465501e-017, 4.36464333e-023],
[1.00000000e+000, 1.64440161e-014, 1.13341951e-021],
[1.00000000e+000, 8.68192867e-017, 6.71630735e-023],
[7.15007036e-050, 9.99997055e-001, 2.94492877e-006],
[1.73414331e-178, 2.06441448e-003, 9.97935586e-001],
[1.00000000e+000, 4.90168069e-019, 3.86471595e-024],
[1.35600871e-156, 2.28929843e-002, 9.77107016e-001],
[1.00000000e+000, 1.78544881e-015, 1.09390819e-020],
[1.86074590e-058, 9.99948860e-001, 5.11400371e-005],
[3.69548269e-057, 9.99992986e-001, 7.01435008e-006]])
accuracy_score(y_test,clf.predict(Xtest))
0.9736842105263158
import numpy as np
import pandas as pd
import random
dataSet=pd.read_csv('iris.txt',header=None)
dataSet.head(10)
0
1
2
3
4
0
5.1
3.5
1.4
0.2
Iris-setosa
1
4.9
3.0
1.4
0.2
Iris-setosa
2
4.7
3.2
1.3
0.2
Iris-setosa
3
4.6
3.1
1.5
0.2
Iris-setosa
4
5.0
3.6
1.4
0.2
Iris-setosa
5
5.4
3.9
1.7
0.4
Iris-setosa
6
4.6
3.4
1.4
0.3
Iris-setosa
7
5.0
3.4
1.5
0.2
Iris-setosa
8
4.4
2.9
1.4
0.2
Iris-setosa
9
4.9
3.1
1.5
0.1
Iris-setosa
dataSet.shape
dataSet.index
list(dataSet.index)
[0,
1,
2,
3,
4,
5,
6,
7,
8,
9,
10,
11,
12,
13,
14,
15,
16,
17,
18,
19,
20,
21,
22,
23,
24,
25,
26,
27,
28,
29,
30,
31,
32,
33,
34,
35,
36,
37,
38,
39,
40,
41,
42,
43,
44,
45,
46,
47,
48,
49,
50,
51,
52,
53,
54,
55,
56,
57,
58,
59,
60,
61,
62,
63,
64,
65,
66,
67,
68,
69,
70,
71,
72,
73,
74,
75,
76,
77,
78,
79,
80,
81,
82,
83,
84,
85,
86,
87,
88,
89,
90,
91,
92,
93,
94,
95,
96,
97,
98,
99,
100,
101,
102,
103,
104,
105,
106,
107,
108,
109,
110,
111,
112,
113,
114,
115,
116,
117,
118,
119,
120,
121,
122,
123,
124,
125,
126,
127,
128,
129,
130,
131,
132,
133,
134,
135,
136,
137,
138,
139,
140,
141,
142,
143,
144,
145,
146,
147,
148,
149]
import random
def randSplit(dataSet,rate):
l=list(dataSet.index)
random.shuffle(l)
dataSet.index=l
n=dataSet.shape[0]
m=int(n*rate)
train=dataSet.loc[range(m),:]
test=dataSet.loc[range(m,n),:]
dataSet.index=range(dataSet.shape[0])
test.index=range(test.shape[0])
return train,test
x_train,x_test=randSplit(dataSet,0.8)
x_train
0
1
2
3
4
0
5.0
3.5
1.3
0.3
Iris-setosa
1
5.6
2.7
4.2
1.3
Iris-versicolor
2
6.3
3.3
4.7
1.6
Iris-versicolor
3
4.4
3.0
1.3
0.2
Iris-setosa
4
5.5
2.6
4.4
1.2
Iris-versicolor
5
6.4
3.1
5.5
1.8
Iris-virginica
6
4.9
2.4
3.3
1.0
Iris-versicolor
7
5.4
3.9
1.3
0.4
Iris-setosa
8
6.0
3.4
4.5
1.6
Iris-versicolor
9
6.4
2.8
5.6
2.2
Iris-virginica
10
5.0
3.5
1.6
0.6
Iris-setosa
11
6.0
2.7
5.1
1.6
Iris-versicolor
12
5.0
2.0
3.5
1.0
Iris-versicolor
13
4.9
3.0
1.4
0.2
Iris-setosa
14
5.1
3.3
1.7
0.5
Iris-setosa
15
6.3
2.5
4.9
1.5
Iris-versicolor
16
5.6
2.9
3.6
1.3
Iris-versicolor
17
5.0
3.3
1.4
0.2
Iris-setosa
18
7.3
2.9
6.3
1.8
Iris-virginica
19
4.6
3.2
1.4
0.2
Iris-setosa
20
5.8
4.0
1.2
0.2
Iris-setosa
21
6.5
3.0
5.2
2.0
Iris-virginica
22
5.5
2.3
4.0
1.3
Iris-versicolor
23
5.1
3.8
1.9
0.4
Iris-setosa
24
6.3
2.9
5.6
1.8
Iris-virginica
25
5.2
2.7
3.9
1.4
Iris-versicolor
26
6.7
2.5
5.8
1.8
Iris-virginica
27
4.9
2.5
4.5
1.7
Iris-virginica
28
6.7
3.0
5.2
2.3
Iris-virginica
29
7.1
3.0
5.9
2.1
Iris-virginica
...
...
...
...
...
...
90
7.2
3.2
6.0
1.8
Iris-virginica
91
7.0
3.2
4.7
1.4
Iris-versicolor
92
5.4
3.4
1.7
0.2
Iris-setosa
93
5.8
2.7
4.1
1.0
Iris-versicolor
94
6.8
3.0
5.5
2.1
Iris-virginica
95
5.1
3.7
1.5
0.4
Iris-setosa
96
5.6
3.0
4.1
1.3
Iris-versicolor
97
5.7
2.9
4.2
1.3
Iris-versicolor
98
6.0
2.2
4.0
1.0
Iris-versicolor
99
7.6
3.0
6.6
2.1
Iris-virginica
100
6.5
3.2
5.1
2.0
Iris-virginica
101
4.5
2.3
1.3
0.3
Iris-setosa
102
5.7
2.5
5.0
2.0
Iris-virginica
103
5.4
3.4
1.5
0.4
Iris-setosa
104
7.4
2.8
6.1
1.9
Iris-virginica
105
5.8
2.7
5.1
1.9
Iris-virginica
106
6.2
3.4
5.4
2.3
Iris-virginica
107
4.6
3.6
1.0
0.2
Iris-setosa
108
6.1
3.0
4.9
1.8
Iris-virginica
109
5.0
3.6
1.4
0.2
Iris-setosa
110
5.5
2.5
4.0
1.3
Iris-versicolor
111
6.2
2.8
4.8
1.8
Iris-virginica
112
6.5
3.0
5.8
2.2
Iris-virginica
113
6.7
3.1
4.4
1.4
Iris-versicolor
114
4.8
3.0
1.4
0.1
Iris-setosa
115
6.1
2.9
4.7
1.4
Iris-versicolor
116
5.9
3.2
4.8
1.8
Iris-versicolor
117
4.9
3.1
1.5
0.1
Iris-setosa
118
6.3
3.4
5.6
2.4
Iris-virginica
119
5.8
2.7
3.9
1.2
Iris-versicolor
120 rows × 5 columns
x_test
0
1
2
3
4
0
5.7
4.4
1.5
0.4
Iris-setosa
1
6.4
2.7
5.3
1.9
Iris-virginica
2
6.0
3.0
4.8
1.8
Iris-virginica
3
5.1
3.8
1.5
0.3
Iris-setosa
4
4.8
3.4
1.6
0.2
Iris-setosa
5
4.6
3.1
1.5
0.2
Iris-setosa
6
6.5
3.0
5.5
1.8
Iris-virginica
7
4.9
3.1
1.5
0.1
Iris-setosa
8
6.3
2.5
5.0
1.9
Iris-virginica
9
5.4
3.9
1.7
0.4
Iris-setosa
10
5.1
3.4
1.5
0.2
Iris-setosa
11
5.1
3.5
1.4
0.2
Iris-setosa
12
4.8
3.0
1.4
0.3
Iris-setosa
13
6.6
2.9
4.6
1.3
Iris-versicolor
14
5.9
3.0
5.1
1.8
Iris-virginica
15
5.2
3.4
1.4
0.2
Iris-setosa
16
7.7
2.6
6.9
2.3
Iris-virginica
17
5.4
3.0
4.5
1.5
Iris-versicolor
18
5.8
2.7
5.1
1.9
Iris-virginica
19
6.7
3.0
5.0
1.7
Iris-versicolor
20
5.8
2.6
4.0
1.2
Iris-versicolor
21
4.7
3.2
1.6
0.2
Iris-setosa
22
6.3
3.3
6.0
2.5
Iris-virginica
23
5.0
2.3
3.3
1.0
Iris-versicolor
24
5.3
3.7
1.5
0.2
Iris-setosa
25
5.7
3.8
1.7
0.3
Iris-setosa
26
6.7
3.1
4.7
1.5
Iris-versicolor
27
7.9
3.8
6.4
2.0
Iris-virginica
28
5.1
2.5
3.0
1.1
Iris-versicolor
29
6.2
2.9
4.3
1.3
Iris-versicolor
labels=x_train.loc[:,4]#标签索引
labels=x_train.iloc[:,-1]#位置索引
labels
0 Iris-setosa
1 Iris-versicolor
2 Iris-versicolor
3 Iris-setosa
4 Iris-versicolor
5 Iris-virginica
6 Iris-versicolor
7 Iris-setosa
8 Iris-versicolor
9 Iris-virginica
10 Iris-setosa
11 Iris-versicolor
12 Iris-versicolor
13 Iris-setosa
14 Iris-setosa
15 Iris-versicolor
16 Iris-versicolor
17 Iris-setosa
18 Iris-virginica
19 Iris-setosa
20 Iris-setosa
21 Iris-virginica
22 Iris-versicolor
23 Iris-setosa
24 Iris-virginica
25 Iris-versicolor
26 Iris-virginica
27 Iris-virginica
28 Iris-virginica
29 Iris-virginica
...
90 Iris-virginica
91 Iris-versicolor
92 Iris-setosa
93 Iris-versicolor
94 Iris-virginica
95 Iris-setosa
96 Iris-versicolor
97 Iris-versicolor
98 Iris-versicolor
99 Iris-virginica
100 Iris-virginica
101 Iris-setosa
102 Iris-virginica
103 Iris-setosa
104 Iris-virginica
105 Iris-virginica
106 Iris-virginica
107 Iris-setosa
108 Iris-virginica
109 Iris-setosa
110 Iris-versicolor
111 Iris-virginica
112 Iris-virginica
113 Iris-versicolor
114 Iris-setosa
115 Iris-versicolor
116 Iris-versicolor
117 Iris-setosa
118 Iris-virginica
119 Iris-versicolor
Name: 4, Length: 120, dtype: object
labels=x_train.iloc[:,-1].value_counts()
labels
Index(['Iris-versicolor', 'Iris-virginica', 'Iris-setosa'], dtype='object')
labels=x_train.iloc[:,-1].value_counts().index
labels
Index(['Iris-versicolor', 'Iris-virginica', 'Iris-setosa'], dtype='object')
### 计算方差与均值
mean=[]
std=[]
for i in labels:
item=x_train.loc[x_train.iloc[:,-1]==i,:]
m=item.iloc[:,:-1]
item
0
1
2
3
4
0
6.0
2.2
5.0
1.5
Iris-virginica
2
6.0
3.0
4.8
1.8
Iris-virginica
3
5.8
2.7
5.1
1.9
Iris-virginica
6
7.2
3.6
6.1
2.5
Iris-virginica
11
6.3
3.3
6.0
2.5
Iris-virginica
13
6.7
3.0
5.2
2.3
Iris-virginica
18
6.8
3.0
5.5
2.1
Iris-virginica
22
7.4
2.8
6.1
1.9
Iris-virginica
25
6.3
3.4
5.6
2.4
Iris-virginica
26
6.4
3.1
5.5
1.8
Iris-virginica
31
6.1
3.0
4.9
1.8
Iris-virginica
36
7.2
3.0
5.8
1.6
Iris-virginica
37
6.3
2.9
5.6
1.8
Iris-virginica
40
6.1
2.6
5.6
1.4
Iris-virginica
46
7.3
2.9
6.3
1.8
Iris-virginica
52
6.3
2.5
5.0
1.9
Iris-virginica
63
7.9
3.8
6.4
2.0
Iris-virginica
64
7.7
3.8
6.7
2.2
Iris-virginica
65
6.2
3.4
5.4
2.3
Iris-virginica
69
4.9
2.5
4.5
1.7
Iris-virginica
72
6.7
3.3
5.7
2.1
Iris-virginica
73
6.5
3.0
5.2
2.0
Iris-virginica
74
6.9
3.2
5.7
2.3
Iris-virginica
81
6.3
2.7
4.9
1.8
Iris-virginica
82
6.9
3.1
5.4
2.1
Iris-virginica
83
6.4
2.7
5.3
1.9
Iris-virginica
84
7.1
3.0
5.9
2.1
Iris-virginica
86
7.7
2.6
6.9
2.3
Iris-virginica
90
7.7
3.0
6.1
2.3
Iris-virginica
93
5.6
2.8
4.9
2.0
Iris-virginica
94
6.5
3.0
5.8
2.2
Iris-virginica
97
6.4
2.8
5.6
2.1
Iris-virginica
101
6.3
2.8
5.1
1.5
Iris-virginica
102
6.4
2.8
5.6
2.2
Iris-virginica
109
6.8
3.2
5.9
2.3
Iris-virginica
111
7.2
3.2
6.0
1.8
Iris-virginica
112
6.9
3.1
5.1
2.3
Iris-virginica
m
0 4.970270
1 3.383784
2 1.443243
3 0.243243
dtype: float64
mean=[]
std=[]
for i in labels:
item=x_train.loc[x_train.iloc[:,-1]==i,:]
m=item.iloc[:,:-1].mean()
m
0 4.970270
1 3.383784
2 1.443243
3 0.243243
dtype: float64
mean=[]
std=[]
for i in labels:
item=x_train.loc[x_train.iloc[:,-1]==i,:]
m=item.iloc[:,:-1].mean()
s=np.sum((item.iloc[:,:-1]-m)**2)/item.shape[0]
(item.iloc[:,:-1]-m)**2
0
1
2
3
0
0.000884
0.013506
0.020519
0.003221
3
0.325208
0.147290
0.020519
0.001870
7
0.184668
0.266479
0.020519
0.024573
10
0.000884
0.013506
0.024573
0.127275
13
0.004938
0.147290
0.001870
0.001870
14
0.016830
0.007020
0.065924
0.065924
17
0.000884
0.007020
0.001870
0.001870
19
0.137100
0.033776
0.001870
0.001870
20
0.688451
0.379722
0.059167
0.001870
23
0.016830
0.173236
0.208627
0.024573
37
0.325208
0.234047
0.001870
0.001870
40
0.052776
0.013506
0.003221
0.001870
43
0.000884
0.033776
0.059167
0.001870
44
0.137100
0.000263
0.001870
0.003221
45
0.000884
0.147290
0.024573
0.001870
49
0.184668
0.099993
0.003221
0.001870
56
0.028992
0.000263
0.208627
0.001870
59
0.449262
0.147290
0.117816
0.020519
65
0.016830
0.173236
0.024573
0.001870
71
0.016830
0.013506
0.001870
0.003221
74
0.073046
0.033776
0.020519
0.001870
75
0.280614
0.666209
0.001870
0.001870
76
0.325208
0.033776
0.020519
0.001870
77
0.004938
0.080533
0.003221
0.020519
80
0.052776
0.512966
0.003221
0.020519
81
0.000884
0.000263
0.003221
0.001870
84
0.000884
0.000263
0.024573
0.024573
86
0.280614
0.013506
0.020519
0.001870
87
0.028992
0.080533
0.024573
0.001870
92
0.184668
0.000263
0.065924
0.001870
95
0.016830
0.099993
0.003221
0.024573
101
0.221154
1.174587
0.020519
0.003221
103
0.184668
0.000263
0.003221
0.024573
107
0.137100
0.046749
0.196465
0.001870
109
0.000884
0.046749
0.001870
0.001870
114
0.028992
0.147290
0.001870
0.020519
117
0.004938
0.080533
0.003221
0.020519
s
0 0.119386
1 0.137034
2 0.034887
3 0.012725
dtype: float64
mean=[]
std=[]
for i in labels:
item=x_train.loc[x_train.iloc[:,-1]==i,:]
m=item.iloc[:,:-1].mean()
s=np.sum((item.iloc[:,:-1]-m)**2)/item.shape[0]
mean.append(m)
std.append(s)
means=pd.DataFrame(mean,index=labels)
stds=pd.DataFrame(std,index=labels)
mean
[0 5.935714
1 2.766667
2 4.276190
3 1.326190
dtype: float64, 0 6.600000
1 2.978049
2 5.548780
3 2.034146
dtype: float64, 0 4.970270
1 3.383784
2 1.443243
3 0.243243
dtype: float64]
std
[0 0.226105
1 0.101270
2 0.174195
3 0.036695
dtype: float64, 0 0.370732
1 0.092445
2 0.264450
3 0.077858
dtype: float64, 0 0.119386
1 0.137034
2 0.034887
3 0.012725
dtype: float64]
means
0
1
2
3
Iris-versicolor
5.935714
2.766667
4.276190
1.326190
Iris-virginica
6.600000
2.978049
5.548780
2.034146
Iris-setosa
4.970270
3.383784
1.443243
0.243243
stds
0
1
2
3
Iris-versicolor
0.226105
0.101270
0.174195
0.036695
Iris-virginica
0.370732
0.092445
0.264450
0.077858
Iris-setosa
0.119386
0.137034
0.034887
0.012725
for j in range(x_test.shape[0]):
iset=x_test.iloc[j,:-1]
iset
0 6.2
1 2.9
2 4.3
3 1.3
Name: 29, dtype: object
for j in range(x_test.shape[0]):
iset=x_test.iloc[j,:-1].tolist()
iset
[6.2, 2.9, 4.3, 1.3]
for j in range(x_test.shape[0]):
iset=x_test.iloc[j,:-1].tolist()
iprob=np.exp(-1*(iset-means)**2/(stds*2))/np.sqrt(2*np.pi*stds)
iset-means
0
1
2
3
Iris-versicolor
0.264286
0.133333
0.023810
-0.026190
Iris-virginica
-0.400000
-0.078049
-1.248780
-0.734146
Iris-setosa
1.229730
-0.483784
2.856757
1.056757
iprob
0
1
2
3
Iris-versicolor
0.718911
1.148286
9.543013e-01
2.063229e+00
Iris-virginica
0.528037
1.269579
4.066561e-02
4.488144e-02
Iris-setosa
0.002051
0.458797
3.406877e-51
3.100002e-19
iprob[0]
Iris-versicol
更多相关内容 -
matlab-朴素贝叶斯-鸢尾花数据集
2018-08-31 09:42:10朴素贝叶斯算法写的关于鸢尾花分类的程序，有需要的可以自己下载修改使用. -
基于朴素贝叶斯的鸢尾花数据集分类
2022-04-06 10:22:50本博文实现了基于朴素贝叶斯的鸢尾花数据集分类展开全文1.作者介绍
王炜鑫，男，西安工程大学电子信息学院，2021级研究生
研究方向：小型无人直升机模型辨识
电子邮件：446646741@qq.com刘帅波，男，西安工程大学电子信息学院，2021级研究生，张宏伟人工智能课题组
研究方向：机器视觉与人工智能
电子邮件：1461004501@qq.com2.理论知识介绍
2.1算法介绍
Naive Bayes算法，又叫朴素贝叶斯算法，朴素：特征条件独立；贝叶斯：基于贝叶斯定理。属于监督学习的生成模型，实现简单，没有迭代，并有坚实的数学理论（即贝叶斯定理）作为支撑。在大量样本下会有较好的表现，不适用于输入向量的特征条件有关联的场景。
朴素贝叶斯的过程主要分为两个阶段。第一阶段，对实验样本进行分类，分别计算不同条件下其概率。第二阶段，输入测试样本，计算不同条件其概率，比较其概率大小，从而完成对测试样本的分类。下图显示两类实验样本的概率分布情况。
实现样本的分类，需要通过计算条件概率而得到，计算条件概率的方法称为贝叶斯准则。条件概率的计算方法：
其中P(A|B)代表条件B下，结果A发生的概率，P(B|A)代表条件A下，结果B发生的概率，P(B)代表条件B发生的概率，P(A)代表条件A发生的概率。
当条件与结果发生交换，计算P(B|A)的方法，在已知 P(A|B)，P(B)，P(A)的情况下可由如上公式得到。
朴素贝叶斯分类器，其核心方法是通过使用条件概率来实现分类。应用贝叶斯准则可以得：
其中P(ci|x,y)代表中给定某个由x、y表示的数据点，该数据点属于类别 ci 的概率。 而朴素贝叶斯分类器基于一个简单的假定：给定目标值时属性之间相互条件独立。即P(x,y|ci)（i=1,2,3……n）相互独立，互不影响。通过贝叶斯准则，定义贝叶斯分类准则为：如果P(c1|x,y)>P(c2|x,y)，那么属于类别c1; 如果P(c2|x,y)> P(c1|x,y)，那么属于类别 c2;
朴素贝叶斯分类器具体步骤如下：
（1）输入训练样本，统计特征。
（2）完成训练样本的向量化。
（3）计算各个特征的条件概率。
（4）输入测试样本
（5）根据测试样本中提供的特征，计算不同类别的条件概率。
（6）根据最大条件概率，完成测试样本分类。2.2数据集介绍
iris数据集：数据集包含150个样本，对应数据集的每行数据。每行数据包含每个样本的四个特征和样本的类别信息，所以iris数据集是一个150行5列的二维表。通俗地说，iris数据集是用来给花做分类的数据集，每个样本包含了sepal_length(花萼长度)、sepal_width(花萼宽度)、petal_length(花瓣长度)、petal_width(花瓣宽度)四个特征（前4列），我们需要建立一个分类器，分类器可以通过样本的四个特征来判断样本属于山鸢尾、变色鸢尾还是维吉尼亚鸢尾（这三个名词都是花的品种）。下图是样本局部截图：
3.实验代码及结果
3.1 数据集下载
iris数据集下载地址：http://download.tensorflow.org/data/iris_training.csv，下载后重命名为iris.csv，并保存到代码所在文件夹
注意：复制上面网址粘贴到网页空白页，按回车键即可下载该数据集3.2实验代码
#导入数据分析所需要的包 import numpy as np import pandas as pd import matplotlib.pyplot as plt import matplotlib as mpl from sklearn.naive_bayes import GaussianNB from sklearn.model_selection import train_test_split data = pd.read_csv('iris.csv',header=None) x = data.drop([4],axis=1) x = x.drop([0],axis=0) x = np.array(x,dtype=float) print(x) y=pd.Categorical(data[4]).codes print(data[4]) y=y[1:151] print(y) p=x[:,2:5] x_train1,x_test1,y_train1,y_test1=train_test_split(x,y,train_size=0.8,random_state=14) x_train,x_test,y_train,y_test=x_train1,x_test1,y_train1,y_test1 print('训练数据集样本数目：%d，测试数据集样本数目：%d'%(x_train.shape[0],x_test.shape[0])) clf=GaussianNB() ir=clf.fit(x_train,y_train) y_pred=ir.predict(x_test) acc = np.sum(y_test == y_pred)/x_test.shape[0] print('测试集准确度：%.3f'% acc) y_pred = ir.predict(x_train) acc = np.sum(y_train == y_pred)/x_train.shape[0] print('训练集准确度：%.3f'% acc) print('选取前两个特征值') p=x[:,:2] p_train1,p_test1,y_train1,y_test1=train_test_split(p,y,train_size=0.8,random_state=1) p_train,p_test,y_train,y_test=p_train1,p_test1,y_train1,y_test1 print('训练数据集样本数目：%d，测试数据集样本数目：%d'%(p_train.shape[0],p_test.shape[0])) clf=GaussianNB() ir=clf.fit(p_train,y_train) y_pred=ir.predict(p_test) acc = np.sum(y_test == y_pred)/p_test.shape[0] print('测试集准确度：%.3f'% acc) y_pred = ir.predict(p_train) acc = np.sum(y_train == y_pred)/p_train.shape[0] print('训练集准确度：%.3f'% acc) p1_max,p1_min = max(p_test[:,0]),min(p_test[:,0]) p2_max,p2_min = max(p_test[:,1]),min(p_test[:,1]) t1 = np.linspace(p1_min,p1_max,500) t2 = np.linspace(p2_min,p2_max,500) p1,p2 = np.meshgrid(t1,t2)#生成网格采样点 p_test1 = np.stack((p1.flat, p2.flat), axis=1) y_hat = ir.predict(p_test1) mpl.rcParams['font.sans-serif'] = [u'SimHei'] mpl.rcParams['axes.unicode_minus'] = False cm_light = mpl.colors.ListedColormap(['#77E0A0', '#FF8080', '#A0A0FF']) cm_dark = mpl.colors.ListedColormap(['g', 'r', 'b']) plt.figure(facecolor='w') plt.pcolormesh(p1, p2, y_hat.reshape(p1.shape),shading='auto', cmap=cm_light) # 预测值的显示 plt.scatter(p_test[:, 0], p_test[:, 1], c=y_test, edgecolors='k', s=50, cmap=cm_dark) # 样本 plt.xlabel(u'花萼长度', fontsize=14) plt.ylabel(u'花萼宽度', fontsize=14) plt.title(u'GaussianNB对鸢尾花数据的分类结果', fontsize=16) plt.grid(True) plt.xlim(p1_min, p1_max) plt.ylim(p2_min, p2_max) plt.show() print('选取后两个特征值') q=x[:,2:4] q_train1,q_test1,y_train1,y_test1=train_test_split(q,y,train_size=0.8,random_state=1) q_train,q_test,y_train,y_test=q_train1,q_test1,y_train1,y_test1 print('训练数据集样本数目：%d，测试数据集样本数目：%d'%(q_train.shape[0],q_test.shape[0])) clf=GaussianNB() ir=clf.fit(q_train,y_train) y_pred=ir.predict(q_test) acc = np.sum(y_test == y_pred)/q_test.shape[0] print('测试集准确度：%.3f'% acc) y_pred = ir.predict(q_train) acc = np.sum(y_train == y_pred)/q_train.shape[0] print('训练集准确度：%.3f'% acc) q1_max,q1_min = max(q_test[:,0]),min(q_test[:,0]) q2_max,q2_min = max(q_test[:,1]),min(q_test[:,1]) t1 = np.linspace(q1_min,q1_max,500) t2 = np.linspace(q2_min,q2_max,500) q1,q2 = np.meshgrid(t1,t2)#生成网格采样点 q_test1 = np.stack((q1.flat, q2.flat), axis=1) y_hat = ir.predict(q_test1) mpl.rcParams['font.sans-serif'] = [u'SimHei'] mpl.rcParams['axes.unicode_minus'] = False cm_light = mpl.colors.ListedColormap(['#A0FFA0', '#FFA0A0', '#A0A0FF']) cm_dark = mpl.colors.ListedColormap(['g', 'r', 'b']) plt.figure(facecolor='w') plt.pcolormesh(q1, q2, y_hat.reshape(q1.shape),shading='auto', cmap = cm_light) # 预测值的显示 plt.scatter(q_test[:, 0], q_test[:, 1], c=y_test, edgecolors='k', s=50, cmap= cm_dark) # 样本 plt.xlabel(u'花瓣长度', fontsize=14) plt.ylabel(u'花瓣宽度', fontsize=14) plt.title(u'GaussianNB对鸢尾花数据的分类结果', fontsize=16) plt.grid(True) plt.xlim(q1_min, q1_max) plt.ylim(q2_min, q2_max) plt.show()3.2实验结果
(1)取前两个特征值：
(2)取后两个特征值：
改变训练集大小为train_size=0.6
(3)取前两个特征值：
(4)取后两个特征值：
分析：改变训练集与测试集比例后，经过对比分析发现，前两个特征值对检测结果的误差更大，后两个特征值更适合进行分类。训练样本与测试样本之间的比重也会在很大程度上影响到测试误差。
-
朴素贝叶斯处理鸢尾花
2021-03-31 09:21:25朴素贝叶斯处理鸢尾花数据集 朴素贝叶斯公式 上代码 from sklearn import datasets from sklearn.model_selection import GridSearchCV,train_test_split,cross_val_score iris = datasets.load_iris()#下载鸢尾花...展开全文朴素贝叶斯处理鸢尾花数据集
朴素贝叶斯公式
上代码
from sklearn import datasets from sklearn.model_selection import GridSearchCV,train_test_split,cross_val_score iris = datasets.load_iris()#下载鸢尾花数据集 data_x = iris["data"]#特征x # print(data_x) data_y = iris["target"]#类别y #将每一列特征划分成几份区间，标准化 num_1=5#每个特征分成五份，我这里是每个特征都分成5个区间，也可以分开。不过代码自己改 def standard_feature(feature_col,num): max_0 = max(data_x[:,feature_col]) min_0 = min(data_x[:,feature_col]) width_0 = (max_0-min_0)/num for j in range(len(data_x[:,feature_col])): for i in range(1, num + 1): if min_0+(i-1)*width_0<=data_x[j,feature_col]<=min_0+i*width_0: data_x[j,feature_col] =i # print(data_x[j,feature]) break x_col_num = len(data_x[0])#获取列数及特征数目 def get_pb(one_feature,col,x_train): ''' one_feature在该x_train数据集的col列的概率 :param one_feature:查找的特征是啥 :param col: 列 :param x_train: :return: 返回该特征的概率 ''' fea_sum = 0 for i in x_train[:,col]: if i == one_feature: fea_sum+=1 col_all = len(x_train) p_b1 =fea_sum/col_all # if p_b1 == 0: # print("第几列第几个特征个数为0",col,one_feature,len(x_train))#如果当你把x特征分的太细会出现有些特征测试集有但训练集没有。看len(x_train）当这个等于训练集总数第78行会除数为0 return p_b1 for i in range(x_col_num):#data_x将所有特征标准化 standard_feature(i,num_1) x_train,x_test,y_train,y_test = train_test_split(data_x,data_y,test_size=0.3)#拆分成测试集，训练集 print("训练集样本数量",len(x_train)) print("测试集样本数量",len(x_test)) test_PB_list =[]# for row_i in range(len(x_test)): P_B = 1 for col_i in range(x_col_num): one_pb = get_pb(x_test[row_i,col_i],col_i,x_train) P_B *= one_pb #经过for循环得到每个测试集样本的P（B） test_PB_list.append(P_B) print("test_PB_list元素个数",len(test_PB_list)) y =3 y_index_list = []#分别存放对应y的全部训练集的全部列索引，该列表元素的列表索引对应y for y_num in range(y): one_y_index_list =[] for y_index in range(len(y_train)): if y_train[y_index] == y_num: one_y_index_list.append(y_index) y_index_list.append(one_y_index_list) print("训练集中每类拥有索引个数",*[len(a) for a in y_index_list]) y_num_list = [] for y_num in range(y): one_y_num = 0 for y_index in range(len(y_train)): if y_train[y_index] == y_num: one_y_num+=1 y_num_list.append(one_y_num) print("训练集每类拥有个数",y_num_list) test_y_predict =[]#测试集预测Y for test_row in range(len(x_test)):#test_row为测试集每行样本，每行样本都需要计算分类为各个y的概率，哪个概率最大，说明就是哪一类 final_y_P = [] for y_index in range(y): x_train_yindex = x_train[y_index_list[y_index],:] P_BinA = 1 for col_i in range(x_col_num): one_pb = get_pb(x_test[test_row, col_i], col_i, x_train_yindex) P_BinA *= one_pb PAinB=(y_num_list[y_index]/len(y_train))*P_BinA/test_PB_list[test_row] final_y_P.append(PAinB) belong_class = final_y_P.index(max(final_y_P)) test_y_predict.append(belong_class) print(test_y_predict) print(list(y_test)) predict_right_num = 0 for i in range(len(test_y_predict)): if test_y_predict[i] == y_test[i]: predict_right_num+=1 probability = predict_right_num/len(test_y_predict) print("预测正确概率",probability)接下来打算用其他方法实现分类，以鸢尾花为数据集KNN logistic 决策树
-
机器学习之鸢尾花-朴素贝叶斯方法
2021-02-12 15:07:01在所有的机器学习分类算法中，朴素贝叶斯和其他绝大多数的分类算法都不同。 对于大多数的分类算法，比如决策树,KNN,逻辑回归，支持向量机等，他们都是判别方法，也就是直接学习出特征输出Y和特征X之间的关系，要么是...展开全文在所有的机器学习分类算法中，朴素贝叶斯和其他绝大多数的分类算法都不同。 对于大多数的分类算法，比如决策树,KNN,逻辑回归，支持向量机等，他们都是判别方法，也就是直接学习出特征输出Y和特征X之间的关系，要么是决策函数Y=f(X),要么是条件分布P(Y|X)。 朴素贝叶斯方法是基于贝叶斯定理的一组有监督学习算法，即“简单”地假设每对特征之间相互独立，也就是直接找出特征输出Y和特征X的联合分布P(X,Y),然后用P(Y|X)=P(X,Y)/P(X)得出。 朴素贝叶斯很直观，计算量也不大，在很多领域有广泛的应用 在scikit-learn中，一共有3个朴素贝叶斯的分类算法类。 分别是GaussianNB，MultinomialNB和BernoulliNB。 其中GaussianNB就是先验为高斯分布的朴素贝叶斯， MultinomialNB就是先验为多项式分布的朴素贝叶斯， 而BernoulliNB就是先验为伯努利分布的朴素贝叶斯。 就鸢尾花例子而言，高斯朴素贝叶斯的准确率>多项分布朴素贝叶斯准确率>伯努利朴素贝叶斯准确率，大概和数据的分布情况有关，后续专门再针对性的评估和学习一下 如下：
# 在所有的机器学习分类算法中，朴素贝叶斯和其他绝大多数的分类算法都不同。
# 对于大多数的分类算法，比如决策树,KNN,逻辑回归，支持向量机等，他们都是判别方法，也就是直接学习出特征输出Y和特征X之间的关系，要么是决策函数Y=f(X),要么是条件分布P(Y|X)。
# 朴素贝叶斯方法是基于贝叶斯定理的一组有监督学习算法，即“简单”地假设每对特征之间相互独立，也就是直接找出特征输出Y和特征X的联合分布P(X,Y),然后用P(Y|X)=P(X,Y)/P(X)得出。
# 朴素贝叶斯很直观，计算量也不大，在很多领域有广泛的应用
# 在scikit-learn中，一共有3个朴素贝叶斯的分类算法类。
# 分别是GaussianNB，MultinomialNB和BernoulliNB。
# 其中GaussianNB就是先验为高斯分布的朴素贝叶斯，
# MultinomialNB就是先验为多项式分布的朴素贝叶斯，
# 而BernoulliNB就是先验为伯努利分布的朴素贝叶斯。
# GaussianNB类参数
# GaussianNB类的主要参数仅有一个，即先验概率priors，对应Y的各个类别的先验概率P(Y=Ck)。
# 这个值默认不给出，如果不给出此时P(Y=Ck)=mk/m。
# 其中m为训练集样本总数量，mk为输出为第k类别的训练集样本数。
# 如果给出的话就以priors 为准。
# 在使用GaussianNB的fit方法拟合数据后，我们可以进行预测。
# 此时预测有三种方法，包括predict，predict_log_proba和predict_proba。
# GaussianNB一个重要的功能是有 partial_fit方法，这个方法的一般用在如果训练集数据量非常大，一次不能全部载入内存的时候。
# 这时我们可以把训练集分成若干等分，重复调用partial_fit来一步步的学习训练集
# MultinomialNB类参数
# MultinomialNB参数比GaussianNB多，但是一共也只有仅仅3个。
# 其中，参数alpha即为上面的常数λ，如果你没有特别的需要，用默认的1即可。
# 如果发现拟合的不好，需要调优时，可以选择稍大于1或者稍小于1的数。
# 布尔参数fit_prior表示是否要考虑先验概率，如果是false,则所有的样本类别输出都有相同的类别先验概率。
# 否则可以自己用第三个参数class_prior输入先验概率，或者不输入第三个参数class_prior让MultinomialNB自己从训练集样本来计算先验概率，此时的先验概率为P(Y=Ck)=mk/m。
# 其中m为训练集样本总数量，mk为输出为第k类别的训练集样本数。
# BernoulliNB类参数
# BernoulliNB一共有4个参数，其中3个参数的名字和意义和MultinomialNB完全相同。
# 唯一增加的一个参数是binarize。
# 这个参数主要是用来帮BernoulliNB处理二项分布的，可以是数值或者不输入。
# 如果不输入，则BernoulliNB认为每个数据特征都已经是二元的。
# 否则的话，小于binarize的会归为一类，大于binarize的会归为另外一类。
from sklearn.naive_bayes import GaussianNB,MultinomialNB,BernoulliNB
def test_naive_bayes(X_train, X_test, y_train, y_test,X,y):
# 训练数据和测试数据进行标准化
# sc = StandardScaler()
# X_train = sc.fit_transform(X_train)
# X_test = sc.transform(X_test)
scores_train=[]
scores_test=[]
names= ['GaussianNB', 'MultinomialNB', 'BernoulliNB' ]
classifiers = [
GaussianNB(),
MultinomialNB(),
BernoulliNB()
]
h=0.02
X= X[:,:2]
#X = StandardScaler().fit_transform(X)
# X_train = StandardScaler().fit_transform(X_train)
# X_test = StandardScaler().fit_transform(X_test)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.4, random_state=42)
x_min, x_max = X[:, 0].min() - .5, X[:, 0].max() + .5
y_min, y_max = X[:, 1].min() - .5, X[:, 1].max() + .5
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
# just plot the dataset first
#cmap_light = ListedColormap(['#AAAAFF', '#AAFFAA', '#FFAAAA']) # 给不同区域赋以颜色
#cmap_bold = ListedColormap(['#FF0000', '#003300', '#0000FF']) # 给不同属性的点赋以颜色
cmap_bold = ListedColormap(['#AAAAFF', '#AAFFAA', '#FFAAAA']) # 给不同区域赋以颜色
cmap_light = ListedColormap(['#FF0000', '#00FF00', '#0000FF']) # 给不同属性的点赋以颜色
plt.figure(figsize=(10,6))
plt.title("Input data")
plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cmap_light,edgecolors='k')
# Plot the testing points
plt.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cmap_light, alpha=0.5,edgecolors='k')
plt.xlim(xx.min(), xx.max())
plt.ylim(yy.min(), yy.max())
plt.xticks(())
plt.yticks(())
plt.show()
i=1
figure = plt.figure(figsize=(10, 6))
for name, clf in zip(names, classifiers):
ax = plt.subplot(2, 2, i)
clf.fit(X_train, y_train)
score = clf.score(X_test, y_test)
print('模型名称:{}，得分={}'.format(name,score))
# 模型名称:GaussianNB，得分=0.8333333333333334
# 模型名称:MultinomialNB，得分=0.4666666666666667
# 模型名称:BernoulliNB，得分=0.3
#Z = clf.predict_proba(np.c_[xx.ravel(), yy.ravel()])[:, 1]
Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
ax.contourf(xx, yy, Z, cmap=cmap_bold, alpha=.6)
#plt.pcolormesh(xx, yy, Z, cmap=cmap_bold, alpha=.6)
# Plot the training points
ax.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap=cmap_light,edgecolors='k')
# Plot the testing points
ax.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap=cmap_light,edgecolors='k', alpha=0.6)
ax.set_xlim(xx.min(), xx.max())
ax.set_ylim(yy.min(), yy.max())
ax.set_xticks(())
ax.set_yticks(())
ax.set_title(name)
ax.text(xx.max() - .3, yy.min() + .3, ('%.2f' % score).lstrip('0'), size=15, horizontalalignment='right')
i=i+1
plt.show()
if __name__=='__main__':
X_train,X_test,y_train,y_test,X,y=load_data(iris)
# -----------------------逻辑回归--------------------------------
# test_LogisticRegression(X_train,X_test,y_train,y_test)
# test_LogisticRegression_C(X_train, X_test, y_train, y_test)
# test_LogisticRegression_Cpenaltyssolvers(X_train, X_test, y_train, y_test)
# test_LogisticRegression_Cmulti_classsolvers(X_train, X_test, y_train, y_test)
# test_LogisticRegression_penaltyssolvers(X_train, X_test, y_train, y_test)
# test_LogisticRegression_multi_classssolvers(X_train, X_test, y_train, y_test)
# test_LogisticRegression_best(X_train, X_test, y_train, y_test)
# ---------------------K近邻算法-----------------------
#test_KNeighborsClassifier(X_train, X_test, y_train, y_test, X, y)
# ------------------朴素贝叶斯-----------------------
# 高斯朴素贝叶斯
# 多项分布朴素贝叶斯
# 伯努利朴素贝叶斯
test_naive_bayes(X_train, X_test, y_train, y_test, X, y)
# ---------------------决策树-----------------------
# ---------------------K Means聚类-----------------------
# ------------------高斯混合模型聚类-----------------------
# -------------------SVM支撑向量机-----------------------
-
朴素贝叶斯处理鸢尾花数据集分类
2021-05-30 15:52:40(3) 使用朴素贝叶斯处理鸢尾花数据集分类 二、实验内容 （1）导入库，加载鸢尾花数据，输出样本和鸢尾花特征 （2）数据分割，数据分割，形成模型训练数据和测试数据 （3）高斯贝叶斯模型构建 （4）计算预测值并计算... -
机器学习算法-朴素贝叶斯（一）：朴素贝叶斯简介和鸢尾花分类实战（代码附详细注释）
2020-12-24 10:30:03朴素贝叶斯 朴素贝叶斯的介绍 朴素贝叶斯算法（Naive Bayes, NB) 是应用最为广泛的分类算法之一。它是基于贝叶斯定义和特征条件独立假设的分类器方法。由于朴素贝叶斯法基于贝叶斯公式计算得到，有着坚实的数学基础... -
高斯朴素贝叶斯方法进行鸢尾花分类
2020-12-10 01:53:51贝叶斯方法完整代码import seaborn as snsiris = sns.load_dataset('iris')X_iris = iris.drop('species', axis=1)y_iris = iris['species']print(X_iris)from sklearn.cross_validation import train_test_... -
【统计学习方法】朴素贝叶斯对鸢尾花(iris)数据集进行训练预测
2021-09-13 14:54:59本文摘要 ...· 代码目的：利用sklearn提供的高斯贝叶斯模型，对鸢尾花数据集进行学习+预测 作者：CSDN 征途黯然. 1、建议去了解一下，高斯、伯努利、多项式的朴素贝叶斯 2、突然间觉得sklearn很.. -
朴素贝叶斯算法原理、代码实现原理、以及鸢尾花分类代码实现（详细代码原理讲解）
2021-08-11 09:47:11朴素贝叶斯算法原理及鸢尾花分类代码实现 一、概率模型 1、全概率公式(由因推果) 设事件B1,B2,…,Bn构成一个完备事件组,即两两不相容，和为全集且P(Bi)>0,则对任意事件A，有 由因推果的理解：如上图：可以理解... -
利用朴素贝叶斯分析鸢尾花，代码有详细解释。
2018-11-21 20:51:49#导入所需要的包 from sklearn.naive_bayes import GaussianNB import numpy as np import pandas as pd from pandas import Series,DataFrame import matplotlib.pyplot as plt from sklearn.datasets import load_... -
朴素贝叶斯对鸢尾花数据集进行分类
2019-01-09 22:06:00使用高斯朴素贝叶斯对鸢尾花数据进行分类 代码： 1 # 通过朴素贝叶斯对鸢尾花数据进行分类 2 3 from sklearn import datasets 4 from sklearn.model_selection import train_test_split 5 from ... -
机器学习实验：朴素贝叶斯算法实现对iris鸢尾花数据集的分类
2022-04-14 11:54:26机器学习实验：朴素贝叶斯算法实现对iris鸢尾花数据集的分类 实验内容： 通过sklearn提供的贝叶斯算法模型实现对iris鸢尾花数据集的分类及预测 使用PCA降维，并通过matplotlib对决策边进行绘制 代码如下： 导入... -
机器学习(6)--朴素贝叶斯模型算法之鸢尾花数据实验
2018-02-04 00:44:27朴素贝叶斯模型是一种基于贝叶斯定理与特征条件独立假设的分类方法， 是经典的机器学习算法之一，也是为数不多的基于概率论的分类算法。 优点：算法逻辑简单,易于实现 缺点：朴素贝叶斯模型前提是假设属性之间... -
（决策树，朴素贝叶斯，人工神经网络）实现鸢尾花数据集分类
2021-11-25 19:17:15决策树，人工神经网络，朴素贝叶斯，对比分类， -
机器学习算法之贝叶斯算法 2、案例一：鸢尾花数据分类
2021-07-14 11:02:06import numpy as np import pandas as pd import matplotlib.pyplot as plt import matplotlib as mpl ...from sklearn.naive_bayes import GaussianNB, MultinomialNB#高斯贝叶斯和多项式朴素贝叶斯 from -
利用随机森林，斯朴素贝叶斯，支持向量机对鸢尾花数据集进行分类和可视化
2021-11-26 09:36:481. 导入所需要的库文件（准备阶段） import numpy as np import pandas as pd import matplotlib.pyplot as plt from mpl_toolkits import mplot3d import seaborn as sns import warnings warnings.filterwarnings... -
机器学习-利用三种分类器实现鸢尾花分类
2021-02-12 15:07:06利用决策树，KNN和朴素贝叶斯三种分类器，对鸢尾花数据集进行分类。下面是具体的流程和代码：1、 数据读取：实验数据是直接加载的sklearn内置的鸢尾花数据集，共150条数据，包含4个特征，而且是一个三分类问题。from... -
Python实现的朴素贝叶斯分类器示例
2020-09-20 22:16:41主要介绍了Python实现的朴素贝叶斯分类器,结合具体实例形式分析了基于Python实现的朴素贝叶斯分类器相关定义与使用技巧,需要的朋友可以参考下 -
机器学习之朴素贝叶斯（二）以鸢尾花数据集为例实现调库训练
2019-08-13 20:03:46以鸢尾花数据集实现朴素贝叶斯的调库训练并简要介绍函数参数 -
基于朴素贝叶斯网络的iris鸢尾花数据集分类到新闻分类
2020-04-26 01:41:22本篇文章是对最简单的朴素贝叶斯网络的运用进行python实践，先对iris鸢尾花数据集做一个分类预实验，再对实际新闻进行分类预测 有关贝叶斯网络原理可以查看这篇文章 ：贝叶斯网络基础 一、iris鸢尾花数据集分类 1、... -
自编程实现朴素贝叶斯算法，Navie Bayes程序（python），并对鸢尾花数据进行分类。
2021-05-24 16:17:30自编程实现朴素贝叶斯算法，Navie Bayes程序（python），并对鸢尾花数据进行分类。 目录自编程实现朴素贝叶斯算法，Navie Bayes程序（python），并对鸢尾花数据进行分类。朴素贝叶斯完整程序代码运行结果实现过程及... -
朴素贝叶斯算法实现分类以及Matlab实现
2017-07-19 14:27:11这几天一直在看得就是贝叶斯算法实现一个分类问题。大概经过了一下这个过程：看书→\rightarrow算法公式推演→\rightarrow网上查询资料→\rightarrow进一步理解→\rightarrow搜集数据集开始尝试→\rightarrow写代码... -
sklearn应用朴素贝叶斯算法
2022-03-08 12:23:01sklearn应用朴素贝叶斯算法 通过两节知识的学习，相信你对朴素贝叶斯算法有了初步的掌握，本节将实际应用朴素贝叶斯算法，从实战中体会算法的精妙之处。 首先看下面一个简单应用案例： 简单应用案例 假设一个学校有 ... -
朴素贝叶斯算法matlab代码-MATLAB-for-Machine-Learning:Packt出版的《MATLABforMachineLe
2021-05-20 08:30:47朴素贝叶斯算法matlab代码用于机器学习的MATLAB 这是的代码存储库，由发行。 它包含从头到尾完成本书所必需的所有支持项目文件。 关于这本书 对于许多机器学习的研究人员和数学专家来说，MATLAB是首选的语言。 本书... -
python KNN算法实现鸢尾花数据集分类
2020-09-18 13:23:38主要介绍了python KNN算法实现鸢尾花数据集分类，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧 -
鸢尾花线性回归+鸢尾花数据集 Python实现
2018-12-07 12:59:36鸢尾花卉数据集，是一类多重变量分析的数据集。通过花萼长度，花萼宽度，花瓣长度，花瓣宽度4个属性预测鸢尾花卉属于（Setosa，Versicolour，Virginica）三个种类中的哪一类。是机器学习基础学习的典型案例。 -
利用鸢尾花数据集实践贝叶斯分类
2020-12-19 19:36:52前面我们已经详细介绍过鸢尾花数据集以及sklearn的使用，下面我们就来调用sklearn中的贝叶斯分类器来实现鸢尾花数据集的分类。 首先，我们需要导入需要用到的包，模型以及数据集 import numpy as np # 导入sklearn...
