Cách tính hàm mật độ xác suất từ ​​data python

Tìm sự giúp đỡ

Trước hết, tất cả các bản phân phối đều đi kèm với các chức năng trợ giúp. Để có được một số thông tin cơ bản, chúng tôi in chuỗi tài liệu có liên quan.

>>> from scipy.stats import norm

Để tìm sự hỗ trợ, tôi. e. , giới hạn trên và dưới của phân phối, gọi

>>> print['bounds of distribution lower: %s, upper: %s' % norm.support[]]
bounds of distribution lower: -inf, upper: inf

Chúng ta có thể liệt kê tất cả các phương thức và thuộc tính của phân phối với

>>> from scipy.stats import norm

>>> from scipy.stats import norm

Để có được các phương thức chính thực sự, chúng tôi liệt kê các phương thức phân phối cố định. [Chúng tôi giải thích ý nghĩa của phân phối cố định bên dưới]

________số 8_______

Cuối cùng, chúng ta có thể có được danh sách phân phối có sẵn thông qua xem xét nội tâm

>>> dist_continu = [d for d in dir[stats] if
..                 isinstance[getattr[stats, d], stats.rv_continuous]]
>>> dist_discrete = [d for d in dir[stats] if
..                  isinstance[getattr[stats, d], stats.rv_discrete]]
>>> print['number of continuous distributions: %d' % len[dist_continu]]
number of continuous distributions: 107
>>> print['number of discrete distributions:   %d' % len[dist_discrete]]
number of discrete distributions:   19

phương pháp phổ biến

Các phương pháp công cộng chính cho RV liên tục là

• rvs. biến thể ngẫu nhiên

• pdf. Hàm mật độ xác suất

• cdf. Chức năng phân phối tích lũy

• sf. Chức năng sinh tồn [1-CDF]

• ppf. Hàm điểm phần trăm [Nghịch đảo của CDF]

• isf. Chức năng sống sót nghịch đảo [Nghịch đảo của SF]

• số liệu thống kê. Giá trị trung bình trả về, phương sai, độ lệch [Fisher's] hoặc độ nhọn [Fisher's]

• khoảng khăc. khoảnh khắc không trung tâm của phân phối

Hãy lấy một chiếc RV bình thường làm ví dụ

>>> norm.cdf[0]
0.5

Để tính toán

>>> from scipy.stats import norm

>>> norm.cdf[[-1., 0, 1]]
array[[ 0.15865525,  0.5,  0.84134475]]
>>> import numpy as np
>>> norm.cdf[np.array[[-1., 0, 1]]]
array[[ 0.15865525,  0.5,  0.84134475]]

Do đó, các phương thức cơ bản, chẳng hạn như pdf, cdf, v.v., được vector hóa

Các phương pháp hữu ích nói chung khác cũng được hỗ trợ

>>> norm.mean[], norm.std[], norm.var[]
[0.0, 1.0, 1.0]
>>> norm.stats[moments="mv"]
[array[0.0], array[1.0]]

Để tìm trung vị của một phân phối, chúng ta có thể sử dụng hàm điểm phần trăm

>>> from scipy.stats import norm

>>> from scipy.stats import norm

>>> norm.ppf[0.5]
0.0

Để tạo một chuỗi các biến ngẫu nhiên, hãy sử dụng đối số từ khóa

>>> from scipy.stats import norm

>>> norm.rvs[size=3]
array[[-0.35687759,  1.34347647, -0.11710531]]   # random

Đừng nghĩ rằng

>>> from scipy.stats import norm

>>> from scipy.stats import norm

Ở đây,

>>> from scipy.stats import norm

>>> from scipy.stats import norm

Tạo số ngẫu nhiên

Vẽ số ngẫu nhiên dựa vào trình tạo từ gói. Trong các ví dụ trên, dòng số ngẫu nhiên cụ thể không thể lặp lại qua các lần chạy. Để đạt được khả năng tái tạo, bạn có thể tạo một trình tạo số ngẫu nhiên một cách rõ ràng. Trong NumPy, trình tạo là một thể hiện của. Đây là cách kinh điển để tạo một trình tạo

>>> from scipy.stats import norm

Và sửa chữa hạt giống có thể được thực hiện như thế này

>>> from scipy.stats import norm

Cảnh báo

Không sử dụng số này hoặc các giá trị phổ biến như 0. Chỉ sử dụng một tập hợp nhỏ các hạt giống để khởi tạo các không gian trạng thái lớn hơn có nghĩa là có một số trạng thái ban đầu không thể đạt được. Điều này tạo ra một số thành kiến ​​nếu mọi người sử dụng các giá trị như vậy. Một cách tốt để có được một hạt giống là sử dụng một

>>> from scipy.stats import norm

Tham số random_state trong các bản phân phối chấp nhận một thể hiện của lớp hoặc một số nguyên, sau đó được sử dụng để khởi tạo một đối tượng ________0____26 bên trong

>>> from scipy.stats import norm

Để biết thêm thông tin, hãy xem tài liệu của NumPy

Để tìm hiểu thêm về bộ lấy mẫu số ngẫu nhiên được triển khai trong SciPy, hãy xem và

Dịch chuyển và chia tỷ lệ

Tất cả các bản phân phối liên tục đều lấy

>>> from scipy.stats import norm

>>> from scipy.stats import norm

>>> from scipy.stats import norm

Trong nhiều trường hợp, phân phối chuẩn hóa cho một biến ngẫu nhiên

>>> from scipy.stats import norm

>>> from scipy.stats import norm

>>> from scipy.stats import norm

>>> from scipy.stats import norm

Việc sử dụng thông minh

>>> from scipy.stats import norm

>>> from scipy.stats import norm

>>> from scipy.stats import norm

\[F[x] = 1 - \exp[-\lambda x]\]

Bằng cách áp dụng quy tắc chia tỷ lệ ở trên, có thể thấy rằng bằng cách lấy

>>> from scipy.stats import norm

>>> from scipy.stats import norm

Ghi chú

Các bản phân phối có tham số hình dạng có thể yêu cầu nhiều hơn ứng dụng đơn giản của

>>> from scipy.stats import norm

>>> from scipy.stats import norm

Sự phân phối đồng đều cũng thú vị

>>> from scipy.stats import norm

Cuối cùng, nhớ lại từ đoạn trước rằng chúng ta còn lại vấn đề về ý nghĩa của

>>> from scipy.stats import norm

>>> from scipy.stats import norm

>>> from scipy.stats import norm

Vì vậy, để giải thích đầu ra của ví dụ của phần cuối cùng.

>>> from scipy.stats import norm

>>> from scipy.stats import norm

>>> from scipy.stats import norm

Chúng tôi khuyên bạn nên đặt thông số

>>> from scipy.stats import norm

>>> from scipy.stats import norm

Thông số hình dạng

Trong khi một biến ngẫu nhiên liên tục chung có thể được thay đổi và chia tỷ lệ với các tham số

>>> from scipy.stats import norm

>>> from scipy.stats import norm

\[\gamma[x, a] = \frac{\lambda [\lambda x]^{a-1}}{\Gamma[a]} ​​e^{-\lambda x}\;,\]

yêu cầu tham số hình dạng \[a\] . Quan sát rằng cài đặt \[\lambda\] có thể đạt được bằng cách đặt từ khóa

>>> from scipy.stats import norm

Hãy kiểm tra số lượng và tên của các tham số hình dạng của phân phối gamma. [Chúng tôi biết từ trên rằng đây phải là 1. ]

>>> from scipy.stats import norm

Bây giờ, chúng tôi đặt giá trị của biến hình dạng thành 1 để có được phân phối theo cấp số nhân, để chúng tôi dễ dàng so sánh xem chúng tôi có nhận được kết quả như mong đợi hay không

>>> print['bounds of distribution lower: %s, upper: %s' % norm.support[]]
bounds of distribution lower: -inf, upper: inf

Lưu ý rằng chúng ta cũng có thể chỉ định tham số hình dạng là từ khóa

>>> print['bounds of distribution lower: %s, upper: %s' % norm.support[]]
bounds of distribution lower: -inf, upper: inf

Đóng băng một bản phân phối

Vượt qua các từ khóa

>>> from scipy.stats import norm

>>> from scipy.stats import norm

>>> print['bounds of distribution lower: %s, upper: %s' % norm.support[]]
bounds of distribution lower: -inf, upper: inf

Bằng cách sử dụng

>>> from scipy.stats import norm

>>> print['bounds of distribution lower: %s, upper: %s' % norm.support[]]
bounds of distribution lower: -inf, upper: inf

Đây thực sự là những gì chúng ta nên nhận được

Phát thanh truyền hình

Các phương thức cơ bản

>>> from scipy.stats import norm

>>> print['bounds of distribution lower: %s, upper: %s' % norm.support[]]
bounds of distribution lower: -inf, upper: inf

Ở đây, hàng đầu tiên chứa các giá trị tới hạn cho 10 bậc tự do và hàng thứ hai chứa 11 bậc tự do [d. o. f. ]. Do đó, các quy tắc phát sóng cho kết quả giống nhau khi gọi ___0_______53 hai lần

>>> print['bounds of distribution lower: %s, upper: %s' % norm.support[]]
bounds of distribution lower: -inf, upper: inf

Nếu mảng có xác suất, tôi. e. ,

>>> from scipy.stats import norm

>>> from scipy.stats import norm

>>> print['bounds of distribution lower: %s, upper: %s' % norm.support[]]
bounds of distribution lower: -inf, upper: inf

Điểm cụ thể cho các bản phân phối rời rạc

Phân phối rời rạc có hầu hết các phương pháp cơ bản giống như phân phối liên tục. Tuy nhiên,

>>> from scipy.stats import norm

>>> from scipy.stats import norm

>>> from scipy.stats import norm

>>> from scipy.stats import norm

Việc tính toán cdf đòi hỏi một số chú ý thêm. Trong trường hợp phân phối liên tục, hàm phân phối tích lũy, trong hầu hết các trường hợp tiêu chuẩn, hoàn toàn đơn điệu tăng trong giới hạn [a,b] và do đó, có một nghịch đảo duy nhất. Tuy nhiên, cdf của một phân phối rời rạc là một hàm bước, do đó cdf nghịch đảo, i. e. , hàm điểm phần trăm, yêu cầu một định nghĩa khác

>>> print['bounds of distribution lower: %s, upper: %s' % norm.support[]]
bounds of distribution lower: -inf, upper: inf

Để biết thêm thông tin, hãy xem tài liệu

Chúng ta có thể xem phân phối siêu hình học làm ví dụ

>>> print['bounds of distribution lower: %s, upper: %s' % norm.support[]]
bounds of distribution lower: -inf, upper: inf

Nếu chúng ta sử dụng cdf tại một số điểm nguyên và sau đó đánh giá ppf tại các giá trị cdf đó, chẳng hạn, chúng ta sẽ lấy lại các số nguyên ban đầu

>>> print['bounds of distribution lower: %s, upper: %s' % norm.support[]]
bounds of distribution lower: -inf, upper: inf

Nếu chúng ta sử dụng các giá trị không nằm trong các nút của hàm bước cdf, chúng ta sẽ lấy lại số nguyên cao hơn tiếp theo

>>> rv = norm[]
>>> dir[rv]  # reformatted
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__',
 '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__',
 '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__',
 '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__',
 '__str__', '__subclasshook__', '__weakref__', 'a', 'args', 'b', 'cdf',
 'dist', 'entropy', 'expect', 'interval', 'isf', 'kwds', 'logcdf',
 'logpdf', 'logpmf', 'logsf', 'mean', 'median', 'moment', 'pdf', 'pmf',
 'ppf', 'random_state', 'rvs', 'sf', 'stats', 'std', 'var']

phân phối phù hợp

Các phương pháp bổ sung chính của phân phối không bị đóng băng có liên quan đến việc ước tính các tham số phân phối

• Phù hợp. ước tính khả năng tối đa của các tham số phân phối, bao gồm cả vị trí

  và quy mô

• fit_loc_scale. ước tính vị trí và tỷ lệ khi các tham số hình dạng được đưa ra

• nnlf. hàm xác suất nhật ký âm

• mong đợi. tính toán kỳ vọng của một chức năng so với pdf hoặc pmf

Các vấn đề về hiệu suất và nhận xét thận trọng

Hiệu suất của các phương pháp riêng lẻ, về mặt tốc độ, rất khác nhau tùy theo phân phối và phương pháp. Kết quả của một phương pháp thu được theo một trong hai cách. bằng tính toán rõ ràng hoặc bằng thuật toán chung không phụ thuộc vào phân phối cụ thể

Tính toán rõ ràng, một mặt, yêu cầu phương pháp được chỉ định trực tiếp cho phân phối đã cho, thông qua các công thức phân tích hoặc thông qua các hàm đặc biệt trong ____0_______60 hoặc ____0____22 cho ________62. Đây thường là những tính toán tương đối nhanh

Mặt khác, các phương pháp chung được sử dụng nếu phân phối không chỉ định bất kỳ phép tính rõ ràng nào. Để xác định phân phối, chỉ cần một trong pdf hoặc cdf; . Tuy nhiên, các phương pháp gián tiếp này có thể rất chậm. Ví dụ:

>>> from scipy.stats import norm

vấn đề còn lại

Các bản phân phối trong

>>> from scipy.stats import norm

• Các bản phân phối đã được thử nghiệm trên một số phạm vi tham số;

• Ước tính khả năng tối đa phù hợp không hoạt động với các tham số bắt đầu mặc định cho tất cả các bản phân phối và người dùng cần cung cấp các tham số bắt đầu tốt. Ngoài ra, đối với một số phân phối sử dụng công cụ ước tính khả năng tối đa vốn dĩ không phải là lựa chọn tốt nhất

Thực hiện một phân phối liên tục, tôi. e. , phân lớp

>>> from scipy.stats import norm

65

Thực hiện phân phối liên tục khá đơn giản

>>> rv = norm[]
>>> dir[rv]  # reformatted
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__',
 '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__',
 '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__',
 '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__',
 '__str__', '__subclasshook__', '__weakref__', 'a', 'args', 'b', 'cdf',
 'dist', 'entropy', 'expect', 'interval', 'isf', 'kwds', 'logcdf',
 'logpdf', 'logpmf', 'logsf', 'mean', 'median', 'moment', 'pdf', 'pmf',
 'ppf', 'random_state', 'rvs', 'sf', 'stats', 'std', 'var']

>>> rv = norm[]
>>> dir[rv]  # reformatted
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__',
 '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__',
 '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__',
 '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__',
 '__str__', '__subclasshook__', '__weakref__', 'a', 'args', 'b', 'cdf',
 'dist', 'entropy', 'expect', 'interval', 'isf', 'kwds', 'logcdf',
 'logpdf', 'logpmf', 'logsf', 'mean', 'median', 'moment', 'pdf', 'pmf',
 'ppf', 'random_state', 'rvs', 'sf', 'stats', 'std', 'var']

Thật thú vị,

>>> from scipy.stats import norm

>>> rv = norm[]
>>> dir[rv]  # reformatted
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__',
 '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__',
 '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__',
 '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__',
 '__str__', '__subclasshook__', '__weakref__', 'a', 'args', 'b', 'cdf',
 'dist', 'entropy', 'expect', 'interval', 'isf', 'kwds', 'logcdf',
 'logpdf', 'logpmf', 'logsf', 'mean', 'median', 'moment', 'pdf', 'pmf',
 'ppf', 'random_state', 'rvs', 'sf', 'stats', 'std', 'var']

Hãy nhận biết các vấn đề hiệu suất được đề cập trong. Việc tính toán các phương thức chung không xác định có thể trở nên rất chậm, vì chỉ các phương thức chung mới được gọi, về bản chất, chúng không thể sử dụng bất kỳ thông tin cụ thể nào về phân phối. Vì vậy, như một ví dụ cảnh báo

>>> rv = norm[]
>>> dir[rv]  # reformatted
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__',
 '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__',
 '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__',
 '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__',
 '__str__', '__subclasshook__', '__weakref__', 'a', 'args', 'b', 'cdf',
 'dist', 'entropy', 'expect', 'interval', 'isf', 'kwds', 'logcdf',
 'logpdf', 'logpmf', 'logsf', 'mean', 'median', 'moment', 'pdf', 'pmf',
 'ppf', 'random_state', 'rvs', 'sf', 'stats', 'std', 'var']

Nhưng điều này là không chính xác. tích phân trên pdf này phải là 1. Hãy làm cho khoảng tích hợp nhỏ hơn

>>> rv = norm[]
>>> dir[rv]  # reformatted
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__',
 '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__',
 '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__',
 '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__',
 '__str__', '__subclasshook__', '__weakref__', 'a', 'args', 'b', 'cdf',
 'dist', 'entropy', 'expect', 'interval', 'isf', 'kwds', 'logcdf',
 'logpdf', 'logpmf', 'logsf', 'mean', 'median', 'moment', 'pdf', 'pmf',
 'ppf', 'random_state', 'rvs', 'sf', 'stats', 'std', 'var']

Điều này có vẻ tốt hơn. Tuy nhiên, vấn đề bắt nguồn từ thực tế là pdf không được chỉ định trong định nghĩa lớp của phân phối xác định

Phân lớp

>>> from scipy.stats import norm

67

Trong phần sau đây, chúng tôi sử dụng để tạo một phân phối rời rạc có xác suất của chuẩn bị cắt ngắn đối với các khoảng có tâm xung quanh các số nguyên

Thông tin chung

Từ chuỗi tài liệu của rv_discrete,

>>> from scipy.stats import norm

“Bạn có thể xây dựng một rv rời rạc tùy ý trong đó P{X=xk} = pk bằng cách chuyển đến phương thức khởi tạo rv_discrete [thông qua từ khóa values=] một bộ các chuỗi [xk, pk] chỉ mô tả các giá trị đó của X [xk] . ”

Bên cạnh đó, có một số yêu cầu khác để phương pháp này hoạt động

• Tên từ khóa là bắt buộc

• Các điểm hỗ trợ của phân phối xk phải là số nguyên

• Số chữ số có nghĩa [số thập phân] cần được chỉ định

Trên thực tế, nếu hai yêu cầu cuối cùng không được thỏa mãn, một ngoại lệ có thể được đưa ra hoặc các số kết quả có thể không chính xác

Một ví dụ

Hãy làm việc. Đầu tiên

>>> rv = norm[]
>>> dir[rv]  # reformatted
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__',
 '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__',
 '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__',
 '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__',
 '__str__', '__subclasshook__', '__weakref__', 'a', 'args', 'b', 'cdf',
 'dist', 'entropy', 'expect', 'interval', 'isf', 'kwds', 'logcdf',
 'logpdf', 'logpmf', 'logsf', 'mean', 'median', 'moment', 'pdf', 'pmf',
 'ppf', 'random_state', 'rvs', 'sf', 'stats', 'std', 'var']

Và, cuối cùng, chúng ta có thể phân lớp

>>> from scipy.stats import norm

>>> rv = norm[]
>>> dir[rv]  # reformatted
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__',
 '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__',
 '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__',
 '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__',
 '__str__', '__subclasshook__', '__weakref__', 'a', 'args', 'b', 'cdf',
 'dist', 'entropy', 'expect', 'interval', 'isf', 'kwds', 'logcdf',
 'logpdf', 'logpmf', 'logsf', 'mean', 'median', 'moment', 'pdf', 'pmf',
 'ppf', 'random_state', 'rvs', 'sf', 'stats', 'std', 'var']

Bây giờ chúng tôi đã xác định phân phối, chúng tôi có quyền truy cập vào tất cả các phương thức phổ biến của phân phối rời rạc

>>> rv = norm[]
>>> dir[rv]  # reformatted
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__',
 '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__',
 '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__',
 '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__',
 '__str__', '__subclasshook__', '__weakref__', 'a', 'args', 'b', 'cdf',
 'dist', 'entropy', 'expect', 'interval', 'isf', 'kwds', 'logcdf',
 'logpdf', 'logpmf', 'logsf', 'mean', 'median', 'moment', 'pdf', 'pmf',
 'ppf', 'random_state', 'rvs', 'sf', 'stats', 'std', 'var']

>>> rv = norm[]
>>> dir[rv]  # reformatted
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__',
 '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__',
 '__init__', '__le__', '__lt__', '__module__', '__ne__', '__new__',
 '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__',
 '__str__', '__subclasshook__', '__weakref__', 'a', 'args', 'b', 'cdf',
 'dist', 'entropy', 'expect', 'interval', 'isf', 'kwds', 'logcdf',
 'logpdf', 'logpmf', 'logsf', 'mean', 'median', 'moment', 'pdf', 'pmf',
 'ppf', 'random_state', 'rvs', 'sf', 'stats', 'std', 'var']

Kiểm tra việc thực hiện

Hãy tạo một mẫu ngẫu nhiên và so sánh tần suất quan sát được với xác suất

>>> dist_continu = [d for d in dir[stats] if
..                 isinstance[getattr[stats, d], stats.rv_continuous]]
>>> dist_discrete = [d for d in dir[stats] if
..                  isinstance[getattr[stats, d], stats.rv_discrete]]
>>> print['number of continuous distributions: %d' % len[dist_continu]]
number of continuous distributions: 107
>>> print['number of discrete distributions:   %d' % len[dist_discrete]]
number of discrete distributions:   19

Tiếp theo, chúng tôi có thể kiểm tra xem mẫu của chúng tôi có được tạo bởi phân phối rời rạc định mức hay không. Điều này cũng xác minh xem các số ngẫu nhiên có được tạo chính xác hay không

Kiểm tra chi bình phương yêu cầu có một số lượng quan sát tối thiểu trong mỗi thùng. Chúng tôi kết hợp các thùng đuôi thành các thùng lớn hơn để chúng chứa đủ các quan sát

>>> dist_continu = [d for d in dir[stats] if
..                 isinstance[getattr[stats, d], stats.rv_continuous]]
>>> dist_discrete = [d for d in dir[stats] if
..                  isinstance[getattr[stats, d], stats.rv_discrete]]
>>> print['number of continuous distributions: %d' % len[dist_continu]]
number of continuous distributions: 107
>>> print['number of discrete distributions:   %d' % len[dist_discrete]]
number of discrete distributions:   19

>>> dist_continu = [d for d in dir[stats] if
..                 isinstance[getattr[stats, d], stats.rv_continuous]]
>>> dist_discrete = [d for d in dir[stats] if
..                  isinstance[getattr[stats, d], stats.rv_discrete]]
>>> print['number of continuous distributions: %d' % len[dist_continu]]
number of continuous distributions: 107
>>> print['number of discrete distributions:   %d' % len[dist_discrete]]
number of discrete distributions:   19

Giá trị p trong trường hợp này cao, vì vậy chúng tôi có thể khá tự tin rằng mẫu ngẫu nhiên của chúng tôi thực sự được tạo ra bởi phân phối

Thống kê mô tả

x là một mảng có nhiều mảng và chúng tôi có quyền truy cập trực tiếp vào tất cả các phương thức mảng, e. g. ,

>>> dist_continu = [d for d in dir[stats] if
..                 isinstance[getattr[stats, d], stats.rv_continuous]]
>>> dist_discrete = [d for d in dir[stats] if
..                  isinstance[getattr[stats, d], stats.rv_discrete]]
>>> print['number of continuous distributions: %d' % len[dist_continu]]
number of continuous distributions: 107
>>> print['number of discrete distributions:   %d' % len[dist_discrete]]
number of discrete distributions:   19

Làm thế nào để các thuộc tính mẫu so với các đối tác lý thuyết của họ?

>>> dist_continu = [d for d in dir[stats] if
..                 isinstance[getattr[stats, d], stats.rv_continuous]]
>>> dist_discrete = [d for d in dir[stats] if
..                  isinstance[getattr[stats, d], stats.rv_discrete]]
>>> print['number of continuous distributions: %d' % len[dist_continu]]
number of continuous distributions: 107
>>> print['number of discrete distributions:   %d' % len[dist_discrete]]
number of discrete distributions:   19

>>> dist_continu = [d for d in dir[stats] if
..                 isinstance[getattr[stats, d], stats.rv_continuous]]
>>> dist_discrete = [d for d in dir[stats] if
..                  isinstance[getattr[stats, d], stats.rv_discrete]]
>>> print['number of continuous distributions: %d' % len[dist_continu]]
number of continuous distributions: 107
>>> print['number of discrete distributions:   %d' % len[dist_discrete]]
number of discrete distributions:   19

Ghi chú. sử dụng công cụ ước tính không chệch cho phương sai, trong khi np. var là công cụ ước tính sai lệch

Đối với mẫu của chúng tôi, số liệu thống kê mẫu khác một lượng nhỏ so với các đối tác lý thuyết của chúng

T-test và KS-test

Chúng ta có thể sử dụng t-test để kiểm tra xem giá trị trung bình của mẫu của chúng ta có khác biệt đáng kể về mặt thống kê so với kỳ vọng lý thuyết hay không

>>> dist_continu = [d for d in dir[stats] if
..                 isinstance[getattr[stats, d], stats.rv_continuous]]
>>> dist_discrete = [d for d in dir[stats] if
..                  isinstance[getattr[stats, d], stats.rv_discrete]]
>>> print['number of continuous distributions: %d' % len[dist_continu]]
number of continuous distributions: 107
>>> print['number of discrete distributions:   %d' % len[dist_discrete]]
number of discrete distributions:   19

Giá trị p là 0. 7, điều này có nghĩa là với sai số alpha, chẳng hạn như 10%, chúng ta không thể bác bỏ giả thuyết rằng giá trị trung bình của mẫu bằng 0, kỳ vọng của phân phối t chuẩn

Như một bài tập, chúng tôi cũng có thể tính trực tiếp bài kiểm tra của bạn mà không cần sử dụng hàm được cung cấp, hàm này sẽ cho chúng tôi câu trả lời tương tự và do đó, nó cũng vậy

>>> dist_continu = [d for d in dir[stats] if
..                 isinstance[getattr[stats, d], stats.rv_continuous]]
>>> dist_discrete = [d for d in dir[stats] if
..                  isinstance[getattr[stats, d], stats.rv_discrete]]
>>> print['number of continuous distributions: %d' % len[dist_continu]]
number of continuous distributions: 107
>>> print['number of discrete distributions:   %d' % len[dist_discrete]]
number of discrete distributions:   19

Thử nghiệm Kolmogorov-Smirnov có thể được sử dụng để kiểm tra giả thuyết rằng mẫu xuất phát từ phân phối t chuẩn

>>> dist_continu = [d for d in dir[stats] if
..                 isinstance[getattr[stats, d], stats.rv_continuous]]
>>> dist_discrete = [d for d in dir[stats] if
..                  isinstance[getattr[stats, d], stats.rv_discrete]]
>>> print['number of continuous distributions: %d' % len[dist_continu]]
number of continuous distributions: 107
>>> print['number of discrete distributions:   %d' % len[dist_discrete]]
number of discrete distributions:   19

Một lần nữa, giá trị p đủ cao để chúng ta không thể bác bỏ giả thuyết rằng mẫu ngẫu nhiên thực sự được phân phối theo phân phối t. Trong các ứng dụng thực tế, chúng tôi không biết phân phối cơ bản là gì. Nếu chúng ta thực hiện kiểm định Kolmogorov-Smirnov đối với mẫu của chúng ta dựa trên phân phối chuẩn chuẩn, thì chúng ta cũng không thể bác bỏ giả thuyết rằng mẫu của chúng ta được tạo ra bởi phân phối chuẩn vì trong ví dụ này, giá trị p là gần 40%

>>> norm.cdf[0]
0.5

Tuy nhiên, phân phối chuẩn chuẩn có phương sai là 1, trong khi mẫu của chúng tôi có phương sai là 1. 29. Nếu chúng ta chuẩn hóa mẫu của mình và kiểm tra nó theo phân phối chuẩn, thì giá trị p lại đủ lớn để chúng ta không thể bác bỏ giả thuyết rằng mẫu có dạng phân phối chuẩn

>>> norm.cdf[0]
0.5

Ghi chú. Thử nghiệm Kolmogorov-Smirnov giả định rằng chúng tôi kiểm tra phân phối với các tham số đã cho, vì trong trường hợp cuối cùng, chúng tôi ước tính giá trị trung bình và phương sai, giả định này bị vi phạm và phân phối của thống kê thử nghiệm, dựa trên giá trị p,

Đuôi của phân phối

Cuối cùng, chúng ta có thể kiểm tra đuôi trên của phân phối. Chúng ta có thể sử dụng hàm điểm phần trăm ppf, là hàm nghịch đảo của hàm cdf, để lấy các giá trị tới hạn hoặc trực tiếp hơn, chúng ta có thể sử dụng hàm nghịch đảo của hàm tồn tại

>>> norm.cdf[0]
0.5

>>> norm.cdf[0]
0.5

Trong cả ba trường hợp, mẫu của chúng tôi có trọng số ở đuôi trên cao hơn so với phân phối cơ bản. Chúng tôi có thể kiểm tra nhanh một mẫu lớn hơn để xem liệu chúng tôi có khớp gần hơn không. Trong trường hợp này, tần suất thực nghiệm khá gần với xác suất lý thuyết, nhưng nếu chúng ta lặp lại điều này nhiều lần, thì dao động vẫn khá lớn

>>> norm.cdf[0]
0.5

Chúng ta cũng có thể so sánh nó với đuôi của phân phối chuẩn, có trọng số nhỏ hơn ở các đuôi

>>> norm.cdf[0]
0.5

Thử nghiệm chi bình phương có thể được sử dụng để kiểm tra xem đối với một số lượng thùng hữu hạn, tần suất quan sát được có khác biệt đáng kể so với xác suất của phân phối được giả định hay không

>>> norm.cdf[0]
0.5

Chúng tôi thấy rằng phân phối chuẩn chuẩn bị từ chối rõ ràng, trong khi phân phối t chuẩn không thể bị từ chối. Vì phương sai của mẫu của chúng tôi khác với cả hai phân phối tiêu chuẩn, nên chúng tôi có thể làm lại thử nghiệm một lần nữa khi tính đến ước tính cho quy mô và vị trí

Phương pháp phù hợp của phân phối có thể được sử dụng để ước tính các tham số của phân phối và thử nghiệm được lặp lại bằng cách sử dụng xác suất của phân phối ước tính

>>> norm.cdf[0]
0.5

Khi tính đến các tham số ước tính, chúng ta vẫn có thể bác bỏ giả thuyết rằng mẫu của chúng ta đến từ phân phối chuẩn [ở mức 5%], nhưng một lần nữa, với giá trị p là 0. 95, chúng ta không thể bác bỏ phân phối t

Kiểm tra đặc biệt cho phân phối bình thường

Vì phân phối chuẩn là phân phối phổ biến nhất trong thống kê nên có sẵn một số chức năng bổ sung để kiểm tra xem một mẫu có thể được rút ra từ phân phối chuẩn hay không

Đầu tiên, chúng tôi có thể kiểm tra xem độ lệch và độ nhọn của mẫu của chúng tôi có khác biệt đáng kể so với mẫu của phân phối chuẩn hay không

>>> norm.cdf[0]
0.5

Hai bài kiểm tra này được kết hợp trong bài kiểm tra tính quy tắc

>>> norm.cdf[0]
0.5

Trong cả ba thử nghiệm, giá trị p đều rất thấp và chúng ta có thể bác bỏ giả thuyết rằng mẫu của chúng ta có độ lệch và độ nhọn của phân phối chuẩn

Vì độ lệch và độ nhọn của mẫu của chúng tôi dựa trên các khoảnh khắc trung tâm, chúng tôi sẽ nhận được kết quả chính xác như vậy nếu chúng tôi kiểm tra mẫu đã chuẩn hóa

>>> norm.cdf[[-1., 0, 1]]
array[[ 0.15865525,  0.5,  0.84134475]]
>>> import numpy as np
>>> norm.cdf[np.array[[-1., 0, 1]]]
array[[ 0.15865525,  0.5,  0.84134475]]

Bởi vì tính quy tắc bị từ chối mạnh mẽ, chúng tôi có thể kiểm tra xem normaltest có cho kết quả hợp lý cho các trường hợp khác không

>>> norm.cdf[[-1., 0, 1]]
array[[ 0.15865525,  0.5,  0.84134475]]
>>> import numpy as np
>>> norm.cdf[np.array[[-1., 0, 1]]]
array[[ 0.15865525,  0.5,  0.84134475]]

Khi kiểm tra tính chuẩn tắc của một mẫu nhỏ các quan sát có phân phối t và một mẫu lớn các quan sát có phân phối chuẩn, thì trong cả hai trường hợp, chúng ta không thể bác bỏ giả thuyết không rằng mẫu xuất phát từ một phân phối chuẩn. Trong trường hợp đầu tiên, điều này là do thử nghiệm không đủ mạnh để phân biệt biến t và biến ngẫu nhiên phân phối chuẩn trong một mẫu nhỏ

phương tiện so sánh

Thử nghiệm với mẫu có phương tiện giống hệt nhau

>>> norm.cdf[[-1., 0, 1]]
array[[ 0.15865525,  0.5,  0.84134475]]
>>> import numpy as np
>>> norm.cdf[np.array[[-1., 0, 1]]]
array[[ 0.15865525,  0.5,  0.84134475]]

Thử nghiệm với mẫu bằng các phương tiện khác nhau

>>> norm.cdf[[-1., 0, 1]]
array[[ 0.15865525,  0.5,  0.84134475]]
>>> import numpy as np
>>> norm.cdf[np.array[[-1., 0, 1]]]
array[[ 0.15865525,  0.5,  0.84134475]]

Thử nghiệm Kolmogorov-Smirnov cho hai mẫu ks_2samp

Ví dụ: khi cả hai mẫu được rút ra từ cùng một phân phối, chúng tôi không thể bác bỏ giả thuyết không, vì giá trị p cao

>>> norm.cdf[[-1., 0, 1]]
array[[ 0.15865525,  0.5,  0.84134475]]
>>> import numpy as np
>>> norm.cdf[np.array[[-1., 0, 1]]]
array[[ 0.15865525,  0.5,  0.84134475]]

Trong ví dụ thứ hai, với vị trí khác, tôi. e. , có nghĩa là, chúng ta có thể bác bỏ giả thuyết không, vì giá trị p nhỏ hơn 1%

>>> norm.cdf[[-1., 0, 1]]
array[[ 0.15865525,  0.5,  0.84134475]]
>>> import numpy as np
>>> norm.cdf[np.array[[-1., 0, 1]]]
array[[ 0.15865525,  0.5,  0.84134475]]

ước lượng đơn biến

Chúng tôi bắt đầu với một lượng dữ liệu tối thiểu để xem cách thức hoạt động và tác dụng của các tùy chọn khác nhau để lựa chọn băng thông. Dữ liệu được lấy mẫu từ PDF được hiển thị dưới dạng dấu gạch ngang màu xanh lam ở dưới cùng của hình [đây được gọi là biểu đồ thảm]

>>> norm.cdf[[-1., 0, 1]]
array[[ 0.15865525,  0.5,  0.84134475]]
>>> import numpy as np
>>> norm.cdf[np.array[[-1., 0, 1]]]
array[[ 0.15865525,  0.5,  0.84134475]]

>>> norm.cdf[[-1., 0, 1]]
array[[ 0.15865525,  0.5,  0.84134475]]
>>> import numpy as np
>>> norm.cdf[np.array[[-1., 0, 1]]]
array[[ 0.15865525,  0.5,  0.84134475]]

>>> norm.cdf[[-1., 0, 1]]
array[[ 0.15865525,  0.5,  0.84134475]]
>>> import numpy as np
>>> norm.cdf[np.array[[-1., 0, 1]]]
array[[ 0.15865525,  0.5,  0.84134475]]

>>> norm.cdf[[-1., 0, 1]]
array[[ 0.15865525,  0.5,  0.84134475]]
>>> import numpy as np
>>> norm.cdf[np.array[[-1., 0, 1]]]
array[[ 0.15865525,  0.5,  0.84134475]]

>>> norm.mean[], norm.std[], norm.var[]
[0.0, 1.0, 1.0]
>>> norm.stats[moments="mv"]
[array[0.0], array[1.0]]

Chúng tôi thấy rằng có rất ít sự khác biệt giữa Quy tắc của Scott và Quy tắc của Silverman và việc lựa chọn băng thông với lượng dữ liệu hạn chế có lẽ hơi quá rộng. Chúng tôi có thể xác định chức năng băng thông của riêng mình để có được kết quả ít mượt mà hơn

>>> norm.mean[], norm.std[], norm.var[]
[0.0, 1.0, 1.0]
>>> norm.stats[moments="mv"]
[array[0.0], array[1.0]]

>>> norm.cdf[[-1., 0, 1]]
array[[ 0.15865525,  0.5,  0.84134475]]
>>> import numpy as np
>>> norm.cdf[np.array[[-1., 0, 1]]]
array[[ 0.15865525,  0.5,  0.84134475]]

>>> norm.mean[], norm.std[], norm.var[]
[0.0, 1.0, 1.0]
>>> norm.stats[moments="mv"]
[array[0.0], array[1.0]]

>>> norm.mean[], norm.std[], norm.var[]
[0.0, 1.0, 1.0]
>>> norm.stats[moments="mv"]
[array[0.0], array[1.0]]

Chúng tôi thấy rằng nếu chúng tôi đặt băng thông rất hẹp, ước tính thu được cho hàm mật độ xác suất [PDF] chỉ đơn giản là tổng Gaussian xung quanh mỗi điểm dữ liệu

Bây giờ chúng ta lấy một ví dụ thực tế hơn và xem xét sự khác biệt giữa hai quy tắc lựa chọn băng thông có sẵn. Các quy tắc đó được biết là hoạt động tốt đối với [gần giống] các bản phân phối bình thường, nhưng ngay cả đối với các bản phân phối không theo phương thức khá phi bình thường, chúng vẫn hoạt động khá tốt. Là một phân phối không bình thường, chúng tôi lấy phân phối T của Sinh viên với 5 bậc tự do

>>> norm.mean[], norm.std[], norm.var[]
[0.0, 1.0, 1.0]
>>> norm.stats[moments="mv"]
[array[0.0], array[1.0]]

Bây giờ chúng ta xem xét một phân phối lưỡng thức với một đặc trưng Gaussian rộng hơn và hẹp hơn. Chúng tôi hy vọng rằng mật độ này sẽ khó ước tính hơn do các băng thông khác nhau cần thiết để giải quyết chính xác từng tính năng

>>> norm.mean[], norm.std[], norm.var[]
[0.0, 1.0, 1.0]
>>> norm.stats[moments="mv"]
[array[0.0], array[1.0]]

>>> norm.mean[], norm.std[], norm.var[]
[0.0, 1.0, 1.0]
>>> norm.stats[moments="mv"]
[array[0.0], array[1.0]]

>>> norm.mean[], norm.std[], norm.var[]
[0.0, 1.0, 1.0]
>>> norm.stats[moments="mv"]
[array[0.0], array[1.0]]

>>> norm.mean[], norm.std[], norm.var[]
[0.0, 1.0, 1.0]
>>> norm.stats[moments="mv"]
[array[0.0], array[1.0]]

>>> norm.ppf[0.5]
0.0

>>> norm.ppf[0.5]
0.0

>>> norm.ppf[0.5]
0.0

>>> norm.ppf[0.5]
0.0

Đúng như dự đoán, KDE không gần với PDF thực như chúng tôi mong muốn do kích thước đặc trưng khác nhau của hai tính năng của phân phối hai chế độ. Bằng cách giảm một nửa băng thông mặc định [

>>> from scipy.stats import norm

ước lượng đa biến

Với chúng ta có thể thực hiện ước lượng đa biến, cũng như đơn biến. Chúng tôi chứng minh trường hợp hai biến. Đầu tiên, chúng tôi tạo một số dữ liệu ngẫu nhiên với một mô hình trong đó hai biến có tương quan với nhau

>>> norm.ppf[0.5]
0.0

>>> norm.ppf[0.5]
0.0

Sau đó, chúng tôi áp dụng KDE cho dữ liệu

>>> norm.ppf[0.5]
0.0

Cuối cùng, chúng tôi vẽ biểu đồ phân phối hai biến ước tính dưới dạng bản đồ màu và vẽ các điểm dữ liệu riêng lẻ ở trên cùng

>>> norm.ppf[0.5]
0.0

>>> norm.ppf[0.5]
0.0

>>> norm.ppf[0.5]
0.0

>>> norm.mean[], norm.std[], norm.var[]
[0.0, 1.0, 1.0]
>>> norm.stats[moments="mv"]
[array[0.0], array[1.0]]

Tương quan đồ thị đa tỷ lệ [MGC]

Với , chúng ta có thể kiểm tra tính độc lập trên dữ liệu chiều cao và phi tuyến tính. Trước khi bắt đầu, hãy nhập một số gói hữu ích

>>> norm.rvs[size=3]
array[[-0.35687759,  1.34347647, -0.11710531]]   # random

Hãy sử dụng chức năng vẽ biểu đồ tùy chỉnh để vẽ biểu đồ mối quan hệ dữ liệu

>>> norm.rvs[size=3]
array[[-0.35687759,  1.34347647, -0.11710531]]   # random

Trước tiên hãy xem xét một số dữ liệu tuyến tính

>>> norm.rvs[size=3]
array[[-0.35687759,  1.34347647, -0.11710531]]   # random

Mối quan hệ mô phỏng có thể được vẽ dưới đây

>>> norm.rvs[size=3]
array[[-0.35687759,  1.34347647, -0.11710531]]   # random

Bây giờ, chúng ta có thể thấy thống kê thử nghiệm, giá trị p và bản đồ MGC được hiển thị bên dưới. Tỷ lệ tối ưu được hiển thị trên bản đồ dưới dạng chữ “x” màu đỏ

>>> norm.rvs[size=3]
array[[-0.35687759,  1.34347647, -0.11710531]]   # random

Rõ ràng là MGC có thể xác định mối quan hệ giữa các ma trận dữ liệu đầu vào vì giá trị p rất thấp và thống kê kiểm tra MGC tương đối cao. Bản đồ MGC biểu thị mối quan hệ tuyến tính mạnh mẽ. Theo trực giác, điều này là do có nhiều hàng xóm hơn sẽ giúp xác định mối quan hệ tuyến tính giữa \[x\] và \ . Tỷ lệ tối ưu trong trường hợp này tương đương với tỷ lệ toàn cầu, được đánh dấu bằng một điểm màu đỏ trên bản đồ. . The optimal scale in this case is equivalent to the global scale, marked by a red spot on the map.

Điều tương tự cũng có thể được thực hiện đối với tập dữ liệu phi tuyến tính. Các mảng sau \[x\] và \[y\] .

>>> norm.rvs[size=3]
array[[-0.35687759,  1.34347647, -0.11710531]]   # random

Mối quan hệ mô phỏng có thể được vẽ dưới đây

>>> norm.rvs[size=3]
array[[-0.35687759,  1.34347647, -0.11710531]]   # random

Bây giờ, chúng ta có thể thấy thống kê thử nghiệm, giá trị p và bản đồ MGC được hiển thị bên dưới. Tỷ lệ tối ưu được hiển thị trên bản đồ dưới dạng chữ “x” màu đỏ

>>> norm.rvs[size=3]
array[[-0.35687759,  1.34347647, -0.11710531]]   # random

Rõ ràng từ đây, MGC có thể xác định lại mối quan hệ vì giá trị p rất thấp và thống kê kiểm tra MGC tương đối cao. Bản đồ MGC biểu thị mối quan hệ phi tuyến tính mạnh. Tỷ lệ tối ưu trong trường hợp này tương đương với tỷ lệ địa phương, được đánh dấu bằng một điểm màu đỏ trên bản đồ

Tính chênh lệch

Hãy xem xét hai tập hợp điểm. Từ hình bên dưới, rõ ràng là thiết kế bên trái chiếm nhiều không gian hơn thiết kế bên phải. Điều này có thể được định lượng bằng thước đo. Sự khác biệt càng thấp, mẫu càng đồng đều

>>> from scipy.stats import norm

Sử dụng động cơ QMC

Một số bộ lấy mẫu/công cụ QMC được triển khai. Ở đây chúng tôi xem xét hai trong số các phương pháp QMC được sử dụng nhiều nhất. và trình tự

>>> from scipy.stats import norm

Cảnh báo

Các phương pháp QMC yêu cầu sự quan tâm đặc biệt và người dùng phải đọc tài liệu để tránh những cạm bẫy phổ biến. Ví dụ, Sobol’ yêu cầu một số điểm theo lũy thừa 2. Ngoài ra, làm mỏng, đốt cháy hoặc chọn điểm khác có thể phá vỡ các thuộc tính của chuỗi và dẫn đến một tập hợp các điểm không tốt hơn MC

Động cơ QMC nhận biết trạng thái. Có nghĩa là bạn có thể tiếp tục trình tự, bỏ qua một số điểm hoặc đặt lại trình tự đó. Hãy lấy 5 điểm từ. Và sau đó yêu cầu một bộ 5 điểm thứ hai

>>> from scipy.stats import norm

Bây giờ chúng tôi thiết lập lại trình tự. Yêu cầu 5 điểm dẫn đến 5 điểm đầu tiên giống nhau

>>> from scipy.stats import norm

Và ở đây, chúng tôi nâng cao trình tự để có được cùng một bộ 5 điểm thứ hai

>>> from scipy.stats import norm

Ghi chú

Theo mặc định, cả hai và được xáo trộn. Các thuộc tính hội tụ tốt hơn và nó ngăn chặn sự xuất hiện của các đường vân hoặc các mẫu điểm đáng chú ý ở kích thước cao. Không có lý do thực tế nào để không sử dụng phiên bản được xáo trộn

Làm một động cơ QMC, tôi. e. , phân lớp

>>> from scipy.stats import norm

84

Để tạo của riêng bạn, một số phương pháp phải được xác định. Sau đây là một gói ví dụ

>>> from scipy.stats import norm

Sau đó, chúng tôi sử dụng nó như bất kỳ công cụ QMC nào khác

>>> from scipy.stats import norm

Hướng dẫn sử dụng QMC

• QMC có quy tắc. Hãy chắc chắn đọc tài liệu hoặc bạn có thể không có lợi ích gì so với MC

• Sử dụng nếu bạn cần chính xác \[2^m\] điểm.

• cho phép lấy mẫu hoặc bỏ qua một số điểm tùy ý. Điều này phải trả giá bằng tốc độ hội tụ chậm hơn Sobol’

• Không bao giờ loại bỏ các điểm đầu tiên của chuỗi. Nó sẽ phá hủy các thuộc tính

• Tranh giành luôn tốt hơn

• Nếu bạn sử dụng các phương pháp dựa trên LHS, bạn không thể thêm điểm mà không làm mất các thuộc tính của LHS. [Có một số phương pháp để làm như vậy, nhưng điều này không được thực hiện. ]

  Cách tính xác suất từ ​​hàm mật độ xác suất?

  Do đó, xác suất chỉ đơn giản là phép nhân giữa các giá trị mật độ xác suất [trục Y] và số tiền boa [trục X] . Phép nhân được thực hiện trên từng điểm đánh giá và các giá trị nhân này sau đó sẽ được cộng lại để tính xác suất cuối cùng.

  Làm cách nào để tính pmf bằng Python?

  binom. hàm pmf[] được sử dụng để lấy hàm khối lượng xác suất cho một giá trị nhất định của r, n và p . Chúng ta có thể có được phân phối bằng cách chuyển tất cả các giá trị có thể có của r[0 đến n].

  Làm cách nào để tính CDF bằng Python?

  Cách dễ nhất để tính xác suất CDF bình thường trong Python là sử dụng định mức. hàm cdf[] từ thư viện SciPy . Cái này là cái gì? . 96 trong phân phối chuẩn chuẩn gần bằng 0. 975.