B 0d@s0dZddlZddlmZmZddlZddlmZddl m Z m Z ddl m Z ddl mZdd l mZdd lmZdd lmZdd lmZdd lmZmZddlmZdddddgZGddde e edZGdddeZdZGdddeZGdddeZGdddeZ GdddeZ!GdddeZ"dS)z The :mod:`sklearn.naive_bayes` module implements Naive Bayes algorithms. These are supervised learning methods based on applying Bayes' theorem with strong (naive) feature independence assumptions. N)ABCMetaabstractmethod) logsumexp) BaseEstimatorClassifierMixin)binarize)LabelBinarizer)label_binarize) deprecated)safe_sparse_dot)_check_partial_fit_first_call)check_is_fittedcheck_non_negative)_check_sample_weight BernoulliNB GaussianNB MultinomialNB ComplementNB CategoricalNBc@s@eZdZdZeddZeddZddZdd Zd d Z d S) _BaseNBz.Abstract base class for naive Bayes estimatorscCsdS)a(Compute the unnormalized posterior log probability of X I.e. ``log P(c) + log P(x|c)`` for all rows x of X, as an array-like of shape (n_classes, n_samples). Input is passed to _joint_log_likelihood as-is by predict, predict_proba and predict_log_proba. N)selfXrrE/var/www/html/venv/lib/python3.7/site-packages/sklearn/naive_bayes.py_joint_log_likelihood1s z_BaseNB._joint_log_likelihoodcCsdS)zgTo be overridden in subclasses with the actual checks. Only used in predict* methods. Nr)rrrrr_check_X<sz_BaseNB._check_XcCs0t|||}||}|jtj|ddS)a; Perform classification on an array of test vectors X. Parameters ---------- X : array-like of shape (n_samples, n_features) The input samples. Returns ------- C : ndarray of shape (n_samples,) Predicted target values for X. r)axis)rrrclasses_npZargmax)rrjllrrrpredictCs  z_BaseNB.predictcCs8t|||}||}t|dd}|t|jS)a Return log-probability estimates for the test vector X. Parameters ---------- X : array-like of shape (n_samples, n_features) The input samples. Returns ------- C : array-like of shape (n_samples, n_classes) Returns the log-probability of the samples for each class in the model. The columns correspond to the classes in sorted order, as they appear in the attribute :term:`classes_`. r)r)rrrrr atleast_2dT)rrr Z log_prob_xrrrpredict_log_probaVs    z_BaseNB.predict_log_probacCst||S)a Return probability estimates for the test vector X. Parameters ---------- X : array-like of shape (n_samples, n_features) The input samples. Returns ------- C : array-like of shape (n_samples, n_classes) Returns the probability of the samples for each class in the model. The columns correspond to the classes in sorted order, as they appear in the attribute :term:`classes_`. )rexpr$)rrrrr predict_probamsz_BaseNB.predict_probaN) __name__ __module__ __qualname____doc__rrrr!r$r&rrrrr.s  r) metaclassc@speZdZdZdddddZdddZd d Zedd d Zdd dZ dddZ ddZ e de ddZdS)ra Gaussian Naive Bayes (GaussianNB). Can perform online updates to model parameters via :meth:`partial_fit`. For details on algorithm used to update feature means and variance online, see Stanford CS tech report STAN-CS-79-773 by Chan, Golub, and LeVeque: http://i.stanford.edu/pub/cstr/reports/cs/tr/79/773/CS-TR-79-773.pdf Read more in the :ref:`User Guide `. Parameters ---------- priors : array-like of shape (n_classes,) Prior probabilities of the classes. If specified the priors are not adjusted according to the data. var_smoothing : float, default=1e-9 Portion of the largest variance of all features that is added to variances for calculation stability. .. versionadded:: 0.20 Attributes ---------- class_count_ : ndarray of shape (n_classes,) number of training samples observed in each class. class_prior_ : ndarray of shape (n_classes,) probability of each class. classes_ : ndarray of shape (n_classes,) class labels known to the classifier. epsilon_ : float absolute additive value to variances. n_features_in_ : int Number of features seen during :term:`fit`. .. versionadded:: 0.24 feature_names_in_ : ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Defined only when `X` has feature names that are all strings. .. versionadded:: 1.0 sigma_ : ndarray of shape (n_classes, n_features) Variance of each feature per class. .. deprecated:: 1.0 `sigma_` is deprecated in 1.0 and will be removed in 1.2. Use `var_` instead. var_ : ndarray of shape (n_classes, n_features) Variance of each feature per class. .. versionadded:: 1.0 theta_ : ndarray of shape (n_classes, n_features) mean of each feature per class. See Also -------- BernoulliNB : Naive Bayes classifier for multivariate Bernoulli models. CategoricalNB : Naive Bayes classifier for categorical features. ComplementNB : Complement Naive Bayes classifier. MultinomialNB : Naive Bayes classifier for multinomial models. Examples -------- >>> import numpy as np >>> X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]]) >>> Y = np.array([1, 1, 1, 2, 2, 2]) >>> from sklearn.naive_bayes import GaussianNB >>> clf = GaussianNB() >>> clf.fit(X, Y) GaussianNB() >>> print(clf.predict([[-0.8, -1]])) [1] >>> clf_pf = GaussianNB() >>> clf_pf.partial_fit(X, Y, np.unique(Y)) GaussianNB() >>> print(clf_pf.predict([[-0.8, -1]])) [1] Ng& .>)priors var_smoothingcCs||_||_dS)N)r,r-)rr,r-rrr__init__szGaussianNB.__init__cCs&|j|d}|j||t|d|dS)aFit Gaussian Naive Bayes according to X, y. Parameters ---------- X : array-like of shape (n_samples, n_features) Training vectors, where `n_samples` is the number of samples and `n_features` is the number of features. y : array-like of shape (n_samples,) Target values. sample_weight : array-like of shape (n_samples,), default=None Weights applied to individual samples (1. for unweighted). .. versionadded:: 0.17 Gaussian Naive Bayes supports fitting with *sample_weight*. Returns ------- self : object Returns the instance itself. )yT)_refit sample_weight)_validate_data _partial_fitrunique)rrr/r1rrrfits zGaussianNB.fitcCs|j|ddS)z*Validate X, used only in predict* methods.F)reset)r2)rrrrrrszGaussianNB._check_XcCs|jddkr||fS|dk rTt|}tj|d|d}tj||dd|d}n&|jd}tj|dd}tj|dd}|dkr||fSt||}|||||} ||} ||} | | |||||d} | |} | | fS)aCompute online update of Gaussian mean and variance. Given starting sample count, mean, and variance, a new set of points X, and optionally sample weights, return the updated mean and variance. (NB - each dimension (column) in X is treated as independent -- you get variance, not covariance). Can take scalar mean and variance, or vector mean and variance to simultaneously update a number of independent Gaussians. See Stanford CS tech report STAN-CS-79-773 by Chan, Golub, and LeVeque: http://i.stanford.edu/pub/cstr/reports/cs/tr/79/773/CS-TR-79-773.pdf Parameters ---------- n_past : int Number of samples represented in old mean and variance. If sample weights were given, this should contain the sum of sample weights represented in old mean and variance. mu : array-like of shape (number of Gaussians,) Means for Gaussians in original set. var : array-like of shape (number of Gaussians,) Variances for Gaussians in original set. sample_weight : array-like of shape (n_samples,), default=None Weights applied to individual samples (1. for unweighted). Returns ------- total_mu : array-like of shape (number of Gaussians,) Updated mean for each Gaussian over the combined set. total_var : array-like of shape (number of Gaussians,) Updated variance for each Gaussian over the combined set. rN)rweights)r)shapefloatsumrZaveragevarZmean)Zn_pastmur<rr1Zn_newZnew_muZnew_varZn_totalZtotal_muZold_ssdZnew_ssdZ total_ssdZ total_varrrr_update_mean_variances$(    z GaussianNB._update_mean_variancecCs|j|||d|dS)a{Incremental fit on a batch of samples. This method is expected to be called several times consecutively on different chunks of a dataset so as to implement out-of-core or online learning. This is especially useful when the whole dataset is too big to fit in memory at once. This method has some performance and numerical stability overhead, hence it is better to call partial_fit on chunks of data that are as large as possible (as long as fitting in the memory budget) to hide the overhead. Parameters ---------- X : array-like of shape (n_samples, n_features) Training vectors, where `n_samples` is the number of samples and `n_features` is the number of features. y : array-like of shape (n_samples,) Target values. classes : array-like of shape (n_classes,), default=None List of all the classes that can possibly appear in the y vector. Must be provided at the first call to partial_fit, can be omitted in subsequent calls. sample_weight : array-like of shape (n_samples,), default=None Weights applied to individual samples (1. for unweighted). .. versionadded:: 0.17 Returns ------- self : object Returns the instance itself. F)r0r1)r3)rrr/classesr1rrr partial_fitEs(zGaussianNB.partial_fitFc Cs|r d|_t||}|j|||d\}}|dk r:t||}|jtj|dd|_|r|j d}t |j}t ||f|_ t ||f|_ tj |tjd|_|jdk rt|j} t | |krtdt| dstd | dkrtd | |_ntj t |jtjd|_nZ|j d|j j dkrRd } t| |j d|j j df|j ddddf|j8<|j}t|} t| |} t| std | | |fx| D]} || }||| kddf}|dk r||| k}|}nd}|j d}||j||j |ddf|j |ddf||\}}||j |ddf<||j |ddf<|j||7<qW|j ddddf|j7<|jdkr|j|j|_|S) aActual implementation of Gaussian NB fitting. Parameters ---------- X : array-like of shape (n_samples, n_features) Training vectors, where `n_samples` is the number of samples and `n_features` is the number of features. y : array-like of shape (n_samples,) Target values. classes : array-like of shape (n_classes,), default=None List of all the classes that can possibly appear in the y vector. Must be provided at the first call to partial_fit, can be omitted in subsequent calls. _refit : bool, default=False If true, act as though this were the first time we called _partial_fit (ie, throw away any past fitting and start over). sample_weight : array-like of shape (n_samples,), default=None Weights applied to individual samples (1. for unweighted). Returns ------- self : object N)r6r)rr)dtypez.Number of priors must match number of classes.g?z"The sum of the priors should be 1.zPriors must be non-negative.z6Number of features %d does not match previous data %d.zBThe target label(s) %s in y do not exist in the initial classes %s)rr r2rr-rr<maxZepsilon_r9lenzerostheta_var_float64 class_count_r,Zasarray ValueErroriscloser;any class_prior_r4Zin1dallZ searchsortedr>)rrr/r?r0r1 first_call n_features n_classesr,msgZunique_yZunique_y_in_classesZy_iiZX_iZsw_iZN_iZ new_thetaZ new_sigmarrrr3qsf                  4  zGaussianNB._partial_fitc Csg}xtt|jD]}t|j|}dttdtj|j|ddf}|dt||j |ddfd|j|ddfd8}| ||qWt |j }|S)Ngg@g?r8r) rangersizerlogrLr;pirFrEappendarrayr#)rrZjoint_log_likelihoodrRZjointiZn_ijrrrrs,< z GaussianNB._joint_log_likelihoodzWAttribute `sigma_` was deprecated in 1.0 and will be removed in1.2. Use `var_` instead.cCs|jS)N)rF)rrrrsigma_szGaussianNB.sigma_)N)N)NN)NFN)r'r(r)r*r.r5r staticmethodr>r@r3rr propertyrYrrrrrsW  G , t g|=c@seZdZdZddZdddZddd Zd d Zdd d Zd ddZ ddZ e de ddZ e de ddZddZe de ddZdS)!_BaseDiscreteNBzAbstract base class for naive Bayes on discrete/categorical data Any estimator based on this class should provide: __init__ _joint_log_likelihood(X) as per _BaseNB cCs|j|dddS)z*Validate X, used only in predict* methods.csrF) accept_sparser6)r2)rrrrrrsz_BaseDiscreteNB._check_XTcCs|j||d|dS)z Validate X and y in fit methods.r])r^r6)r2)rrr/r6rrr _check_X_y sz_BaseDiscreteNB._check_X_yNc Cst|j}|dk r4t||kr&tdt||_n`|jr~tt dt t|j }WdQRX|t|j |_nt |t| |_dS)Nz.Number of priors must match number of classes.ignore)rCrrIrrUclass_log_prior_ fit_priorwarningscatch_warnings simplefilterRuntimeWarningrHr;full)r class_priorrPZlog_class_countrrr_update_class_log_prior s    z'_BaseDiscreteNB._update_class_log_priorcCs~t|jdkr$tdt|jt|jtjrL|jjd|jksLtdt|jtkrxt dtt |jtS|jS)Nrz6Smoothing parameter alpha = %.1e. alpha should be > 0.zAalpha should be a scalar or a numpy array with shape [n_features]zCalpha too small will result in numeric errors, setting alpha = %.1e) rminalpharI isinstanceZndarrayr9n_features_in_ _ALPHA_MINrcwarnmaximum)rrrr _check_alphasz_BaseDiscreteNB._check_alphac Cs2t|d }|j|||d\}}|j\}}t||rHt|}|||t||jd} | jddkrt|jdkrtj d| | fdd} n t | } |jd| jdkrd} t | |jd|jdf| j tj d d } |d k rt||}t|}| |j9} |j} ||| |} || |j| d |S) aGIncremental fit on a batch of samples. This method is expected to be called several times consecutively on different chunks of a dataset so as to implement out-of-core or online learning. This is especially useful when the whole dataset is too big to fit in memory at once. This method has some performance overhead hence it is better to call partial_fit on chunks of data that are as large as possible (as long as fitting in the memory budget) to hide the overhead. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Training vectors, where `n_samples` is the number of samples and `n_features` is the number of features. y : array-like of shape (n_samples,) Target values. classes : array-like of shape (n_classes,), default=None List of all the classes that can possibly appear in the y vector. Must be provided at the first call to partial_fit, can be omitted in subsequent calls. sample_weight : array-like of shape (n_samples,), default=None Weights applied to individual samples (1. for unweighted). Returns ------- self : object Returns the instance itself. r)r6)r?rr8)rrz1X.shape[0]=%d and y.shape[0]=%d are incompatible.F)copyN)rh)hasattrr_r9r rC_init_countersr rr concatenate ones_likerIastyperGrr"r#rh_countrq_update_feature_log_probri) rrr/r?r1rN_rOrPYrQrhrkrrrr@2s2%           z_BaseDiscreteNB.partial_fitc Cs|||\}}|j\}}t}||}|j|_|jddkrpt|jdkrftjd||fdd}n t|}|dk r|j tj dd}t ||}t |}||j 9}|j}|jd} || |||||} || |j|d|S)a_Fit Naive Bayes classifier according to X, y. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Training vectors, where `n_samples` is the number of samples and `n_features` is the number of features. y : array-like of shape (n_samples,) Target values. sample_weight : array-like of shape (n_samples,), default=None Weights applied to individual samples (1. for unweighted). Returns ------- self : object Returns the instance itself. rr8)rNF)rr)rh)r_r9r Z fit_transformrrCrrurvrwrGrr"r#rhrtrxrqryri) rrr/r1rzrOZlabelbinr{rhrPrkrrrr5s,           z_BaseDiscreteNB.fitcCs,tj|tjd|_tj||ftjd|_dS)N)rA)rrDrGrHfeature_count_)rrPrOrrrrtsz_BaseDiscreteNB._init_countersz_Attribute `coef_` was deprecated in version 0.24 and will be removed in 1.1 (renaming of 0.26).cCs"t|jdkr|jddS|jS)Nr8r)rCrfeature_log_prob_)rrrrcoef_sz_BaseDiscreteNB.coef_zdAttribute `intercept_` was deprecated in version 0.24 and will be removed in 1.1 (renaming of 0.26).cCs"t|jdkr|jddS|jS)Nr8r)rCrra)rrrr intercept_sz_BaseDiscreteNB.intercept_cCsddiS)NZ poor_scoreTr)rrrr _more_tagssz_BaseDiscreteNB._more_tagszoAttribute `n_features_` was deprecated in version 1.0 and will be removed in 1.2. Use `n_features_in_` instead.cCs|jS)N)rm)rrrr n_features_sz_BaseDiscreteNB.n_features_)T)N)NN)N)r'r(r)r*rr_rirqr@r5rtr r[r~rrrrrrrr\s$   Q 5 r\c@sBeZdZdZddddddZdd Zd d Zd d ZddZdS)raC Naive Bayes classifier for multinomial models. The multinomial Naive Bayes classifier is suitable for classification with discrete features (e.g., word counts for text classification). The multinomial distribution normally requires integer feature counts. However, in practice, fractional counts such as tf-idf may also work. Read more in the :ref:`User Guide `. Parameters ---------- alpha : float, default=1.0 Additive (Laplace/Lidstone) smoothing parameter (0 for no smoothing). fit_prior : bool, default=True Whether to learn class prior probabilities or not. If false, a uniform prior will be used. class_prior : array-like of shape (n_classes,), default=None Prior probabilities of the classes. If specified the priors are not adjusted according to the data. Attributes ---------- class_count_ : ndarray of shape (n_classes,) Number of samples encountered for each class during fitting. This value is weighted by the sample weight when provided. class_log_prior_ : ndarray of shape (n_classes,) Smoothed empirical log probability for each class. classes_ : ndarray of shape (n_classes,) Class labels known to the classifier coef_ : ndarray of shape (n_classes, n_features) Mirrors ``feature_log_prob_`` for interpreting `MultinomialNB` as a linear model. .. deprecated:: 0.24 ``coef_`` is deprecated in 0.24 and will be removed in 1.1 (renaming of 0.26). feature_count_ : ndarray of shape (n_classes, n_features) Number of samples encountered for each (class, feature) during fitting. This value is weighted by the sample weight when provided. feature_log_prob_ : ndarray of shape (n_classes, n_features) Empirical log probability of features given a class, ``P(x_i|y)``. intercept_ : ndarray of shape (n_classes,) Mirrors ``class_log_prior_`` for interpreting `MultinomialNB` as a linear model. .. deprecated:: 0.24 ``intercept_`` is deprecated in 0.24 and will be removed in 1.1 (renaming of 0.26). n_features_ : int Number of features of each sample. .. deprecated:: 1.0 Attribute `n_features_` was deprecated in version 1.0 and will be removed in 1.2. Use `n_features_in_` instead. n_features_in_ : int Number of features seen during :term:`fit`. .. versionadded:: 0.24 feature_names_in_ : ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Defined only when `X` has feature names that are all strings. .. versionadded:: 1.0 See Also -------- BernoulliNB : Naive Bayes classifier for multivariate Bernoulli models. CategoricalNB : Naive Bayes classifier for categorical features. ComplementNB : Complement Naive Bayes classifier. GaussianNB : Gaussian Naive Bayes. Notes ----- For the rationale behind the names `coef_` and `intercept_`, i.e. naive Bayes as a linear classifier, see J. Rennie et al. (2003), Tackling the poor assumptions of naive Bayes text classifiers, ICML. References ---------- C.D. Manning, P. Raghavan and H. Schuetze (2008). Introduction to Information Retrieval. Cambridge University Press, pp. 234-265. https://nlp.stanford.edu/IR-book/html/htmledition/naive-bayes-text-classification-1.html Examples -------- >>> import numpy as np >>> rng = np.random.RandomState(1) >>> X = rng.randint(5, size=(6, 100)) >>> y = np.array([1, 2, 3, 4, 5, 6]) >>> from sklearn.naive_bayes import MultinomialNB >>> clf = MultinomialNB() >>> clf.fit(X, y) MultinomialNB() >>> print(clf.predict(X[2:3])) [3] g?TN)rkrbrhcCs||_||_||_dS)N)rkrbrh)rrkrbrhrrrr.UszMultinomialNB.__init__cCsddiS)Nrequires_positive_XTr)rrrrrZszMultinomialNB._more_tagscCs:t|d|jt|j|7_|j|jdd7_dS)z%Count and smooth feature occurrences.zMultinomialNB (input X)r)rN)rr|r r#rHr;)rrr{rrrrx]s zMultinomialNB._countcCs8|j|}|jdd}t|t|dd|_dS)z=Apply smoothing to raw counts and recompute log probabilitiesr)rN)r|r;rrUreshaper})rrk smoothed_fc smoothed_ccrrrrycs   z&MultinomialNB._update_feature_log_probcCst||jj|jS)z8Calculate the posterior log probability of the samples X)r r}r#ra)rrrrrrlsz#MultinomialNB._joint_log_likelihood) r'r(r)r*r.rrxryrrrrrrs o c@sDeZdZdZdddddddZd d Zd d Zd dZddZdS)raThe Complement Naive Bayes classifier described in Rennie et al. (2003). The Complement Naive Bayes classifier was designed to correct the "severe assumptions" made by the standard Multinomial Naive Bayes classifier. It is particularly suited for imbalanced data sets. Read more in the :ref:`User Guide `. .. versionadded:: 0.20 Parameters ---------- alpha : float, default=1.0 Additive (Laplace/Lidstone) smoothing parameter (0 for no smoothing). fit_prior : bool, default=True Only used in edge case with a single class in the training set. class_prior : array-like of shape (n_classes,), default=None Prior probabilities of the classes. Not used. norm : bool, default=False Whether or not a second normalization of the weights is performed. The default behavior mirrors the implementations found in Mahout and Weka, which do not follow the full algorithm described in Table 9 of the paper. Attributes ---------- class_count_ : ndarray of shape (n_classes,) Number of samples encountered for each class during fitting. This value is weighted by the sample weight when provided. class_log_prior_ : ndarray of shape (n_classes,) Smoothed empirical log probability for each class. Only used in edge case with a single class in the training set. classes_ : ndarray of shape (n_classes,) Class labels known to the classifier coef_ : ndarray of shape (n_classes, n_features) Mirrors ``feature_log_prob_`` for interpreting `ComplementNB` as a linear model. .. deprecated:: 0.24 ``coef_`` is deprecated in 0.24 and will be removed in 1.1 (renaming of 0.26). feature_all_ : ndarray of shape (n_features,) Number of samples encountered for each feature during fitting. This value is weighted by the sample weight when provided. feature_count_ : ndarray of shape (n_classes, n_features) Number of samples encountered for each (class, feature) during fitting. This value is weighted by the sample weight when provided. feature_log_prob_ : ndarray of shape (n_classes, n_features) Empirical weights for class complements. intercept_ : ndarray of shape (n_classes,) Mirrors ``class_log_prior_`` for interpreting `ComplementNB` as a linear model. .. deprecated:: 0.24 ``coef_`` is deprecated in 0.24 and will be removed in 1.1 (renaming of 0.26). n_features_ : int Number of features of each sample. .. deprecated:: 1.0 Attribute `n_features_` was deprecated in version 1.0 and will be removed in 1.2. Use `n_features_in_` instead. n_features_in_ : int Number of features seen during :term:`fit`. .. versionadded:: 0.24 feature_names_in_ : ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Defined only when `X` has feature names that are all strings. .. versionadded:: 1.0 See Also -------- BernoulliNB : Naive Bayes classifier for multivariate Bernoulli models. CategoricalNB : Naive Bayes classifier for categorical features. GaussianNB : Gaussian Naive Bayes. MultinomialNB : Naive Bayes classifier for multinomial models. References ---------- Rennie, J. D., Shih, L., Teevan, J., & Karger, D. R. (2003). Tackling the poor assumptions of naive bayes text classifiers. In ICML (Vol. 3, pp. 616-623). https://people.csail.mit.edu/jrennie/papers/icml03-nb.pdf Examples -------- >>> import numpy as np >>> rng = np.random.RandomState(1) >>> X = rng.randint(5, size=(6, 100)) >>> y = np.array([1, 2, 3, 4, 5, 6]) >>> from sklearn.naive_bayes import ComplementNB >>> clf = ComplementNB() >>> clf.fit(X, y) ComplementNB() >>> print(clf.predict(X[2:3])) [3] g?TNF)rkrbrhnormcCs||_||_||_||_dS)N)rkrbrhr)rrkrbrhrrrrr.szComplementNB.__init__cCsddiS)NrTr)rrrrrszComplementNB._more_tagscCsJt|d|jt|j|7_|j|jdd7_|jjdd|_dS)zCount feature occurrences.zComplementNB (input X)r)rN)rr|r r#rHr; feature_all_)rrr{rrrrxs zComplementNB._countcCsV|j||j}t||jddd}|jrF|jddd}||}n| }||_dS)z6Apply smoothing to raw counts and compute the weights.rT)rZkeepdimsN)rr|rrUr;rr})rrkZ comp_countZloggedZsummedfeature_log_probrrrrys z%ComplementNB._update_feature_log_probcCs*t||jj}t|jdkr&||j7}|S)z0Calculate the class scores for the samples in X.r)r r}r#rCrra)rrr rrrrs z"ComplementNB._joint_log_likelihood) r'r(r)r*r.rrxryrrrrrrqs p csZeZdZdZdddddddZfd d Zdfd d Zd dZddZddZ Z S)raNaive Bayes classifier for multivariate Bernoulli models. Like MultinomialNB, this classifier is suitable for discrete data. The difference is that while MultinomialNB works with occurrence counts, BernoulliNB is designed for binary/boolean features. Read more in the :ref:`User Guide `. Parameters ---------- alpha : float, default=1.0 Additive (Laplace/Lidstone) smoothing parameter (0 for no smoothing). binarize : float or None, default=0.0 Threshold for binarizing (mapping to booleans) of sample features. If None, input is presumed to already consist of binary vectors. fit_prior : bool, default=True Whether to learn class prior probabilities or not. If false, a uniform prior will be used. class_prior : array-like of shape (n_classes,), default=None Prior probabilities of the classes. If specified the priors are not adjusted according to the data. Attributes ---------- class_count_ : ndarray of shape (n_classes,) Number of samples encountered for each class during fitting. This value is weighted by the sample weight when provided. class_log_prior_ : ndarray of shape (n_classes,) Log probability of each class (smoothed). classes_ : ndarray of shape (n_classes,) Class labels known to the classifier coef_ : ndarray of shape (n_classes, n_features) Mirrors ``feature_log_prob_`` for interpreting `BernoulliNB` as a linear model. feature_count_ : ndarray of shape (n_classes, n_features) Number of samples encountered for each (class, feature) during fitting. This value is weighted by the sample weight when provided. feature_log_prob_ : ndarray of shape (n_classes, n_features) Empirical log probability of features given a class, P(x_i|y). intercept_ : ndarray of shape (n_classes,) Mirrors ``class_log_prior_`` for interpreting `BernoulliNB` as a linear model. n_features_ : int Number of features of each sample. .. deprecated:: 1.0 Attribute `n_features_` was deprecated in version 1.0 and will be removed in 1.2. Use `n_features_in_` instead. n_features_in_ : int Number of features seen during :term:`fit`. .. versionadded:: 0.24 feature_names_in_ : ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Defined only when `X` has feature names that are all strings. .. versionadded:: 1.0 See Also -------- CategoricalNB : Naive Bayes classifier for categorical features. ComplementNB : The Complement Naive Bayes classifier described in Rennie et al. (2003). GaussianNB : Gaussian Naive Bayes (GaussianNB). MultinomialNB : Naive Bayes classifier for multinomial models. References ---------- C.D. Manning, P. Raghavan and H. Schuetze (2008). Introduction to Information Retrieval. Cambridge University Press, pp. 234-265. https://nlp.stanford.edu/IR-book/html/htmledition/the-bernoulli-model-1.html A. McCallum and K. Nigam (1998). A comparison of event models for naive Bayes text classification. Proc. AAAI/ICML-98 Workshop on Learning for Text Categorization, pp. 41-48. V. Metsis, I. Androutsopoulos and G. Paliouras (2006). Spam filtering with naive Bayes -- Which naive Bayes? 3rd Conf. on Email and Anti-Spam (CEAS). Examples -------- >>> import numpy as np >>> rng = np.random.RandomState(1) >>> X = rng.randint(5, size=(6, 100)) >>> Y = np.array([1, 2, 3, 4, 4, 5]) >>> from sklearn.naive_bayes import BernoulliNB >>> clf = BernoulliNB() >>> clf.fit(X, Y) BernoulliNB() >>> print(clf.predict(X[2:3])) [3] g?gTN)rkrrbrhcCs||_||_||_||_dS)N)rkrrbrh)rrkrrbrhrrrr.sszBernoulliNB.__init__cs(t|}|jdk r$t||jd}|S)z*Validate X, used only in predict* methods.N) threshold)superrr)rr) __class__rrrys  zBernoulliNB._check_Xcs6tj|||d\}}|jdk r.t||jd}||fS)N)r6)r)rr_r)rrr/r6)rrrr_s zBernoulliNB._check_X_ycCs0|jt|j|7_|j|jdd7_dS)z%Count and smooth feature occurrences.r)rN)r|r r#rHr;)rrr{rrrrxszBernoulliNB._countcCs:|j|}|j|d}t|t|dd|_dS)z=Apply smoothing to raw counts and recompute log probabilitiesr8rrN)r|rHrrUrr})rrkrrrrrrys  z$BernoulliNB._update_feature_log_probcCsp|jjd}|jd}||kr.td||ftdt|j}t||j|j}||j|j dd7}|S)z8Calculate the posterior log probability of the samples Xrz/Expected input with %d features, got %d instead)r) r}r9rIrrUr%r r#rar;)rrrOZ n_features_XZneg_probr rrrrs   z!BernoulliNB._joint_log_likelihood)T) r'r(r)r*r.rr_rxryr __classcell__rr)rrrsj  cseZdZdZdddddddZdfdd Zdfd d Zd d ZddZdddZ ddZ e ddZ ddZ ddZddZZS)raNaive Bayes classifier for categorical features. The categorical Naive Bayes classifier is suitable for classification with discrete features that are categorically distributed. The categories of each feature are drawn from a categorical distribution. Read more in the :ref:`User Guide `. Parameters ---------- alpha : float, default=1.0 Additive (Laplace/Lidstone) smoothing parameter (0 for no smoothing). fit_prior : bool, default=True Whether to learn class prior probabilities or not. If false, a uniform prior will be used. class_prior : array-like of shape (n_classes,), default=None Prior probabilities of the classes. If specified the priors are not adjusted according to the data. min_categories : int or array-like of shape (n_features,), default=None Minimum number of categories per feature. - integer: Sets the minimum number of categories per feature to `n_categories` for each features. - array-like: shape (n_features,) where `n_categories[i]` holds the minimum number of categories for the ith column of the input. - None (default): Determines the number of categories automatically from the training data. .. versionadded:: 0.24 Attributes ---------- category_count_ : list of arrays of shape (n_features,) Holds arrays of shape (n_classes, n_categories of respective feature) for each feature. Each array provides the number of samples encountered for each class and category of the specific feature. class_count_ : ndarray of shape (n_classes,) Number of samples encountered for each class during fitting. This value is weighted by the sample weight when provided. class_log_prior_ : ndarray of shape (n_classes,) Smoothed empirical log probability for each class. classes_ : ndarray of shape (n_classes,) Class labels known to the classifier feature_log_prob_ : list of arrays of shape (n_features,) Holds arrays of shape (n_classes, n_categories of respective feature) for each feature. Each array provides the empirical log probability of categories given the respective feature and class, ``P(x_i|y)``. n_features_ : int Number of features of each sample. .. deprecated:: 1.0 Attribute `n_features_` was deprecated in version 1.0 and will be removed in 1.2. Use `n_features_in_` instead. n_features_in_ : int Number of features seen during :term:`fit`. .. versionadded:: 0.24 feature_names_in_ : ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Defined only when `X` has feature names that are all strings. .. versionadded:: 1.0 n_categories_ : ndarray of shape (n_features,), dtype=np.int64 Number of categories for each feature. This value is inferred from the data or set by the minimum number of categories. .. versionadded:: 0.24 See Also -------- BernoulliNB : Naive Bayes classifier for multivariate Bernoulli models. ComplementNB : Complement Naive Bayes classifier. GaussianNB : Gaussian Naive Bayes. MultinomialNB : Naive Bayes classifier for multinomial models. Examples -------- >>> import numpy as np >>> rng = np.random.RandomState(1) >>> X = rng.randint(5, size=(6, 100)) >>> y = np.array([1, 2, 3, 4, 5, 6]) >>> from sklearn.naive_bayes import CategoricalNB >>> clf = CategoricalNB() >>> clf.fit(X, y) CategoricalNB() >>> print(clf.predict(X[2:3])) [3] g?TN)rkrbrhmin_categoriescCs||_||_||_||_dS)N)rkrbrhr)rrkrbrhrrrrr. szCategoricalNB.__init__cstj|||dS)aFit Naive Bayes classifier according to X, y. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Training vectors, where `n_samples` is the number of samples and `n_features` is the number of features. Here, each feature of X is assumed to be from a different categorical distribution. It is further assumed that all categories of each feature are represented by the numbers 0, ..., n - 1, where n refers to the total number of categories for the given feature. This can, for instance, be achieved with the help of OrdinalEncoder. y : array-like of shape (n_samples,) Target values. sample_weight : array-like of shape (n_samples,), default=None Weights applied to individual samples (1. for unweighted). Returns ------- self : object Returns the instance itself. )r1)rr5)rrr/r1)rrrr5szCategoricalNB.fitcstj||||dS)aIncremental fit on a batch of samples. This method is expected to be called several times consecutively on different chunks of a dataset so as to implement out-of-core or online learning. This is especially useful when the whole dataset is too big to fit in memory at once. This method has some performance overhead hence it is better to call partial_fit on chunks of data that are as large as possible (as long as fitting in the memory budget) to hide the overhead. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Training vectors, where `n_samples` is the number of samples and `n_features` is the number of features. Here, each feature of X is assumed to be from a different categorical distribution. It is further assumed that all categories of each feature are represented by the numbers 0, ..., n - 1, where n refers to the total number of categories for the given feature. This can, for instance, be achieved with the help of OrdinalEncoder. y : array-like of shape (n_samples,) Target values. classes : array-like of shape (n_classes,), default=None List of all the classes that can possibly appear in the y vector. Must be provided at the first call to partial_fit, can be omitted in subsequent calls. sample_weight : array-like of shape (n_samples,), default=None Weights applied to individual samples (1. for unweighted). Returns ------- self : object Returns the instance itself. )r1)rr@)rrr/r?r1)rrrr@0s*zCategoricalNB.partial_fitcCsddiS)NrTr)rrrrr\szCategoricalNB._more_tagscCs"|j|ddddd}t|d|S)z*Validate X, used only in predict* methods.intFT)rAr^force_all_finiter6zCategoricalNB (input X))r2r)rrrrrr_s zCategoricalNB._check_XcCs,|j||ddd|d\}}t|d||fS)NrFT)rAr^rr6zCategoricalNB (input X))r2r)rrr/r6rrrr_gs zCategoricalNB._check_X_ycs.tjtjd|_fddt|D|_dS)N)rAcsg|]}tdfqS)r)rrD).0rz)rPrr psz0CategoricalNB._init_counters..)rrDrGrHrScategory_count_)rrPrOr)rPrrtnszCategoricalNB._init_counterscCs|jddd}t|}|dk rt|jtjsDtd|jdtj||tjd}|j |j krtd|j dd|j d|S|SdS) Nr)rrz0'min_categories' should have integral type. Got z instead.)rAz$'min_categories' should have shape (z',) when an array-like is provided. Got ) rBrrXZ issubdtyperAZ signedintegerrIrpint64r9)rrZn_categories_XZmin_categories_ n_categories_rrr_validate_n_categoriesrs  z$CategoricalNB._validate_n_categoriescCsdd}dd}|j|jdd7_|||j|_x^t|jD]P}|dd|f}||j||j|d|j|<||||j||jjdqBWdS)NcSs4|d|jd}|dkr0t|dd|fgdS|S)Nrr)rrZconstant)r9rpad) cat_countZhighest_featurediffrrr_update_cat_count_dimssz4CategoricalNB._count.._update_cat_count_dimsc Ssx~t|D]r}|dd|ft}|jjtjkr8d}n |||f}tj|||d}t|d}|||f||7<q WdS)N)r7r) rSrwboolrAtyperrZbincountZnonzero) X_featurer{rrPjmaskr7countsindicesrrr_update_cat_counts z/CategoricalNB._count.._update_cat_countr)rr) rHr;rrrrSrmrr9)rrr{rrrRrrrrrxs zCategoricalNB._countc Cs^g}xNt|jD]@}|j||}|jdd}|t|t|ddqW||_dS)Nr)rr) rSrmrr;rWrrUrr})rrkrrRZsmoothed_cat_countZsmoothed_class_countrrrrys "z&CategoricalNB._update_feature_log_probcCsx|j|ddt|jd|jjdf}x>t|jD]0}|dd|f}||j|dd|fj7}q6W||j }|S)NF)r6r) Z_check_n_featuresrrDr9rHrSrmr}r#ra)rrr rRrZtotal_llrrrrs  z#CategoricalNB._joint_log_likelihood)N)NN)T)r'r(r)r*r.r5r@rrr_rtrZrrxryrrrr)rrrsd,   )#r*rcabcrrnumpyrZ scipy.specialrbaserrZ preprocessingrr r utilsr Z utils.extmathr Zutils.multiclassr Zutils.validationrrr__all__rrrnr\rrrrrrrrs@         R{i!