精华内容
下载资源
问答
  • 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

    更多相关内容
  • 朴素贝叶斯算法写的关于鸢尾花分类的程序,有需要的可以自己下载修改使用.
  • 基于朴素贝叶斯鸢尾花数据集分类

    千次阅读 多人点赞 2022-04-06 10:22:50
    本博文实现了基于朴素贝叶斯鸢尾花数据集分类

    1.作者介绍

    王炜鑫,男,西安工程大学电子信息学院,2021级研究生
    研究方向:小型无人直升机模型辨识
    电子邮件:446646741@qq.com

    刘帅波,男,西安工程大学电子信息学院,2021级研究生,张宏伟人工智能课题组
    研究方向:机器视觉与人工智能
    电子邮件:1461004501@qq.com

    2.理论知识介绍

    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

    136be34314a57ba454d97dfa8ef5d707.png

    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)计算预测值并计算...
  • 朴素贝叶斯 朴素贝叶斯的介绍 朴素贝叶斯算法(Naive Bayes, NB) 是应用最为广泛的分类算法之一。它是基于贝叶斯定义和特征条件独立假设的分类器方法。由于朴素贝叶斯法基于贝叶斯公式计算得到,有着坚实的数学基础...
  • 贝叶斯方法完整代码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_...
  • 本文摘要 ...· 代码目的:利用sklearn提供的高斯贝叶斯模型,对鸢尾花数据集进行学习+预测 作者:CSDN 征途黯然.    1、建议去了解一下,高斯、伯努利、多项式的朴素贝叶斯 2、突然间觉得sklearn很..
  • 朴素贝叶斯算法原理及鸢尾花分类代码实现 一、概率模型 1、全概率公式(由因推果) 设事件B1,B2,…,Bn构成一个完备事件组,即两两不相容,和为全集且P(Bi)>0,则对任意事件A,有 由因推果的理解:如上图:可以理解...
  • #导入所需要的包 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_...
  • 使用高斯朴素贝叶斯鸢尾花数据进行分类 代码: 1 # 通过朴素贝叶斯鸢尾花数据进行分类 2 3 from sklearn import datasets 4 from sklearn.model_selection import train_test_split 5 from ...
  • 机器学习实验:朴素贝叶斯算法实现对iris鸢尾花数据集的分类 实验内容: 通过sklearn提供的贝叶斯算法模型实现对iris鸢尾花数据集的分类及预测 使用PCA降维,并通过matplotlib对决策边进行绘制 代码如下: 导入...
  • 朴素贝叶斯模型是一种基于贝叶斯定理与特征条件独立假设的分类方法, 是经典的机器学习算法之一,也是为数不多的基于概率论的分类算法。 优点:算法逻辑简单,易于实现 缺点:朴素贝叶斯模型前提是假设属性之间...
  • 决策树,人工神经网络,朴素贝叶斯,对比分类,
  • import numpy as np import pandas as pd import matplotlib.pyplot as plt import matplotlib as mpl ...from sklearn.naive_bayes import GaussianNB, MultinomialNB#高斯贝叶斯和多项式朴素贝叶斯 from
  • 1. 导入所需要的库文件(准备阶段) 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...
  • 利用决策树,KNN和朴素贝叶斯三种分类器,对鸢尾花数据集进行分类。下面是具体的流程和代码:1、 数据读取:实验数据是直接加载的sklearn内置的鸢尾花数据集,共150条数据,包含4个特征,而且是一个三分类问题。from...
  • 主要介绍了Python实现的朴素贝叶斯分类器,结合具体实例形式分析了基于Python实现的朴素贝叶斯分类器相关定义与使用技巧,需要的朋友可以参考下
  • 鸢尾花数据集实现朴素贝叶斯的调库训练并简要介绍函数参数
  • 本篇文章是对最简单的朴素贝叶斯网络的运用进行python实践,先对iris鸢尾花数据集做一个分类预实验,再对实际新闻进行分类预测 有关贝叶斯网络原理可以查看这篇文章 :贝叶斯网络基础 一、iris鸢尾花数据集分类 1、...
  • 自编程实现朴素贝叶斯算法,Navie Bayes程序(python),并对鸢尾花数据进行分类。 目录自编程实现朴素贝叶斯算法,Navie Bayes程序(python),并对鸢尾花数据进行分类。朴素贝叶斯完整程序代码运行结果实现过程及...
  • 朴素贝叶斯算法实现分类以及Matlab实现

    万次阅读 多人点赞 2017-07-19 14:27:11
    这几天一直在看得就是贝叶斯算法实现一个分类问题。大概经过了一下这个过程:看书→\rightarrow算法公式推演→\rightarrow网上查询资料→\rightarrow进一步理解→\rightarrow搜集数据集开始尝试→\rightarrow写代码...
  • sklearn应用朴素贝叶斯算法 通过两节知识的学习,相信你对朴素贝叶斯算法有了初步的掌握,本节将实际应用朴素贝叶斯算法,从实战中体会算法的精妙之处。 首先看下面一个简单应用案例: 简单应用案例 假设一个学校有 ...
  • 朴素贝叶斯算法matlab代码用于机器学习的MATLAB 这是的代码存储库,由发行。 它包含从头到尾完成本书所必需的所有支持项目文件。 关于这本书 对于许多机器学习的研究人员和数学专家来说,MATLAB是首选的语言。 本书...
  • 主要介绍了python KNN算法实现鸢尾花数据集分类,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 鸢尾花卉数据集,是一类多重变量分析的数据集。通过花萼长度,花萼宽度,花瓣长度,花瓣宽度4个属性预测鸢尾花卉属于(Setosa,Versicolour,Virginica)三个种类中的哪一类。是机器学习基础学习的典型案例。
  • 利用鸢尾花数据集实践贝叶斯分类

    千次阅读 2020-12-19 19:36:52
    前面我们已经详细介绍过鸢尾花数据集以及sklearn的使用,下面我们就来调用sklearn中的贝叶斯分类器来实现鸢尾花数据集的分类。 首先,我们需要导入需要用到的包,模型以及数据集 import numpy as np # 导入sklearn...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,321
精华内容 528
关键字:

朴素贝叶斯 鸢尾花

友情链接: testprintform.zip