Hướng dẫn how do you generate a random number from a given distribution in python? - làm thế nào để bạn tạo một số ngẫu nhiên từ một phân phối nhất định trong python?

Tạo số ngẫu nhiên là một nhiệm vụ lập trình phổ biến được yêu cầu cho nhiều chương trình và ứng dụng khác nhau. Trong Python, cách phổ biến nhất để tạo ra các số ngẫu nhiên được cho là mô -đun numpy. Numpy nhanh, đáng tin cậy, dễ cài đặt và dựa vào nhiều chương trình.

Tính đến năm 2022 (

>>> accumulate_normalize_values( { 'a': 100, 'b' : 300, 'c' : 400, 'd' : 200  } )
[('a', 0.1), ('c', 0.5), ('b', 0.8), ('d', 1.0)]

Theo dõi cùng với sổ ghi chép Jupyter dưới đây để bắt đầu tìm hiểu tất cả về tạo số ngẫu nhiên.

Điều đầu tiên chúng ta cần làm để tạo ra các số ngẫu nhiên trong Python với

>>> accumulate_normalize_values( { 'a': 100, 'b' : 300, 'c' : 400, 'd' : 200  } )
[('a', 0.1), ('c', 0.5), ('b', 0.8), ('d', 1.0)]

def select(symbol_intervals,random):
        print symbol_intervals,random
        i = 0
        while random > symbol_intervals[i][1]:
                i += 1
                if i >= len(symbol_intervals):
                        raise Exception( "What did you DO to that poor list?" )
        return symbol_intervals[i][0]


def gen_random(alphabet,length,probabilities=None):
        from random import random
        from itertools import repeat
        if probabilities is None:
                probabilities = dict(zip(alphabet,repeat(1.0)))
        elif len(probabilities) > 0 and isinstance(probabilities[0],(int,long,float)):
                probabilities = dict(zip(alphabet,probabilities)) #ordered
        usable_probabilities = accumulate_normalize_values(probabilities)
        gen = []
        while len(gen) < length:
                gen.append(select(usable_probabilities,random()))
        return gen

>>> accumulate_normalize_values( { 'a': 100, 'b' : 300, 'c' : 400, 'd' : 200  } )
[('a', 0.1), ('c', 0.5), ('b', 0.8), ('d', 1.0)]

Hãy bắt đầu bằng cách bắt đầu bằng cách sử dụng một biến

def select(symbol_intervals,random):
        print symbol_intervals,random
        i = 0
        while random > symbol_intervals[i][1]:
                i += 1
                if i >= len(symbol_intervals):
                        raise Exception( "What did you DO to that poor list?" )
        return symbol_intervals[i][0]


def gen_random(alphabet,length,probabilities=None):
        from random import random
        from itertools import repeat
        if probabilities is None:
                probabilities = dict(zip(alphabet,repeat(1.0)))
        elif len(probabilities) > 0 and isinstance(probabilities[0],(int,long,float)):
                probabilities = dict(zip(alphabet,probabilities)) #ordered
        usable_probabilities = accumulate_normalize_values(probabilities)
        gen = []
        while len(gen) < length:
                gen.append(select(usable_probabilities,random()))
        return gen

def select(symbol_intervals,random):
        print symbol_intervals,random
        i = 0
        while random > symbol_intervals[i][1]:
                i += 1
                if i >= len(symbol_intervals):
                        raise Exception( "What did you DO to that poor list?" )
        return symbol_intervals[i][0]


def gen_random(alphabet,length,probabilities=None):
        from random import random
        from itertools import repeat
        if probabilities is None:
                probabilities = dict(zip(alphabet,repeat(1.0)))
        elif len(probabilities) > 0 and isinstance(probabilities[0],(int,long,float)):
                probabilities = dict(zip(alphabet,probabilities)) #ordered
        usable_probabilities = accumulate_normalize_values(probabilities)
        gen = []
        while len(gen) < length:
                gen.append(select(usable_probabilities,random()))
        return gen

In [ ]:

rng = np.random.default_rng()

Số thập phân ngẫu nhiên (điểm nổi, hoặc float) số

Bây giờ, chúng ta có thể sử dụng

def select(symbol_intervals,random):
        print symbol_intervals,random
        i = 0
        while random > symbol_intervals[i][1]:
                i += 1
                if i >= len(symbol_intervals):
                        raise Exception( "What did you DO to that poor list?" )
        return symbol_intervals[i][0]


def gen_random(alphabet,length,probabilities=None):
        from random import random
        from itertools import repeat
        if probabilities is None:
                probabilities = dict(zip(alphabet,repeat(1.0)))
        elif len(probabilities) > 0 and isinstance(probabilities[0],(int,long,float)):
                probabilities = dict(zip(alphabet,probabilities)) #ordered
        usable_probabilities = accumulate_normalize_values(probabilities)
        gen = []
        while len(gen) < length:
                gen.append(select(usable_probabilities,random()))
        return gen

def select(symbol_intervals,random):
        print symbol_intervals,random
        i = 0
        while random > symbol_intervals[i][1]:
                i += 1
                if i >= len(symbol_intervals):
                        raise Exception( "What did you DO to that poor list?" )
        return symbol_intervals[i][0]


def gen_random(alphabet,length,probabilities=None):
        from random import random
        from itertools import repeat
        if probabilities is None:
                probabilities = dict(zip(alphabet,repeat(1.0)))
        elif len(probabilities) > 0 and isinstance(probabilities[0],(int,long,float)):
                probabilities = dict(zip(alphabet,probabilities)) #ordered
        usable_probabilities = accumulate_normalize_values(probabilities)
        gen = []
        while len(gen) < length:
                gen.append(select(usable_probabilities,random()))
        return gen

Để tạo ra một mảng phao ngẫu nhiên, chúng ta có thể chuyển một đối số kích thước thành

def select(symbol_intervals,random):
        print symbol_intervals,random
        i = 0
        while random > symbol_intervals[i][1]:
                i += 1
                if i >= len(symbol_intervals):
                        raise Exception( "What did you DO to that poor list?" )
        return symbol_intervals[i][0]


def gen_random(alphabet,length,probabilities=None):
        from random import random
        from itertools import repeat
        if probabilities is None:
                probabilities = dict(zip(alphabet,repeat(1.0)))
        elif len(probabilities) > 0 and isinstance(probabilities[0],(int,long,float)):
                probabilities = dict(zip(alphabet,probabilities)) #ordered
        usable_probabilities = accumulate_normalize_values(probabilities)
        gen = []
        while len(gen) < length:
                gen.append(select(usable_probabilities,random()))
        return gen

Out[ ]:

array([0.91394253, 0.80736524, 0.21402387, 0.86334362, 0.75628216,
       0.18238176, 0.37567793, 0.36385296, 0.39890072, 0.78487536])

Để tạo ra một mảng đa chiều của các giá trị ngẫu nhiên, chỉ cần truyền một bộ tuple hình dạng thay vì số nguyên cho tham số kích thước. Ví dụ này tạo ra 2 chiều với 3 hàng và 2 cột nổi ngẫu nhiên.

Out[ ]:

array([[0.46270073, 0.21953817],
       [0.57626831, 0.72370476],
       [0.02004972, 0.65277897]])

Gieo hạt cho khả năng tái sản xuất

Có những lúc bạn có thể muốn tạo một số ngẫu nhiên cho một đoạn mã, nhưng giữ số đó giống nhau để mã sao chép cùng một đầu ra. Đây là một nhu cầu phổ biến khi kiểm tra mã và thuật toán. Nếu bạn chạy mã ở trên một lần nữa (bằng cách chạy tập lệnh của bạn hoặc khởi động lại sổ ghi chép của bạn), bạn sẽ nhận thấy rằng mã vẫn tạo ra các số ngẫu nhiên, nhưng chúng là các số khác với được sản xuất lần cuối cùng bạn chạy nó.

Nếu bạn cần số lượng để giữ nguyên cho mục đích thử nghiệm, điều này có thể có vấn đề. Nhưng đừng lo lắng, có một cách để có được mã của bạn để tạo cùng một số ngẫu nhiên mỗi lần.

Cách để có được mã python của bạn để tạo ra cùng một số ngẫu nhiên mỗi lần chạy là gieo hạt trình tạo số ngẫu nhiên khi nó được tạo. Để gieo hạt, chỉ cần truyền một số nguyên (ví dụ

>>> accumulate_normalize_values( { 'a': 100, 'b' : 300, 'c' : 400, 'd' : 200  } )
[('a', 0.1), ('c', 0.5), ('b', 0.8), ('d', 1.0)]

In [ ]:

rng_seed = np.random.default_rng(12345)
rng_seed.random()

Lưu ý rằng nếu bạn chạy tập lệnh này một lần nữa (hoặc khởi động lại sổ ghi chép). Cùng một số ngẫu nhiên sẽ được sản xuất. Nó có vẻ hơi phản trực giác để khóa một số ngẫu nhiên như thế này (tại sao không xác định một biến có số đã đặt?), Nhưng nó làm cho mã trong suốt và cho thấy một số ngẫu nhiên được tạo ra.

Số nguyên ngẫu nhiên

Chúng ta cũng có thể sử dụng

def select(symbol_intervals,random):
        print symbol_intervals,random
        i = 0
        while random > symbol_intervals[i][1]:
                i += 1
                if i >= len(symbol_intervals):
                        raise Exception( "What did you DO to that poor list?" )
        return symbol_intervals[i][0]


def gen_random(alphabet,length,probabilities=None):
        from random import random
        from itertools import repeat
        if probabilities is None:
                probabilities = dict(zip(alphabet,repeat(1.0)))
        elif len(probabilities) > 0 and isinstance(probabilities[0],(int,long,float)):
                probabilities = dict(zip(alphabet,probabilities)) #ordered
        usable_probabilities = accumulate_normalize_values(probabilities)
        gen = []
        while len(gen) < length:
                gen.append(select(usable_probabilities,random()))
        return gen

def select(symbol_intervals,random):
        print symbol_intervals,random
        i = 0
        while random > symbol_intervals[i][1]:
                i += 1
                if i >= len(symbol_intervals):
                        raise Exception( "What did you DO to that poor list?" )
        return symbol_intervals[i][0]


def gen_random(alphabet,length,probabilities=None):
        from random import random
        from itertools import repeat
        if probabilities is None:
                probabilities = dict(zip(alphabet,repeat(1.0)))
        elif len(probabilities) > 0 and isinstance(probabilities[0],(int,long,float)):
                probabilities = dict(zip(alphabet,probabilities)) #ordered
        usable_probabilities = accumulate_normalize_values(probabilities)
        gen = []
        while len(gen) < length:
                gen.append(select(usable_probabilities,random()))
        return gen

Bây giờ, tôi sẽ sử dụng phương thức

>>> gen_random (['a','b','c','d'],10,[100,300,400,200])
['d', 'b', 'b', 'a', 'c', 'c', 'b', 'c', 'c', 'c']   #<--- some of the time

>>> gen_random (['a','b','c','d'],10,[100,300,400,200])
['d', 'b', 'b', 'a', 'c', 'c', 'b', 'c', 'c', 'c']   #<--- some of the time

>>> gen_random (['a','b','c','d'],10,[100,300,400,200])
['d', 'b', 'b', 'a', 'c', 'c', 'b', 'c', 'c', 'c']   #<--- some of the time

>>> gen_random (['a','b','c','d'],10,[100,300,400,200])
['d', 'b', 'b', 'a', 'c', 'c', 'b', 'c', 'c', 'c']   #<--- some of the time

Để tạo ra một mảng các số nguyên ngẫu nhiên trong Python, hãy sử dụng phương thức

>>> gen_random (['a','b','c','d'],10,[100,300,400,200])
['d', 'b', 'b', 'a', 'c', 'c', 'b', 'c', 'c', 'c']   #<--- some of the time

>>> gen_random (['a','b','c','d'],10,[100,300,400,200])
['d', 'b', 'b', 'a', 'c', 'c', 'b', 'c', 'c', 'c']   #<--- some of the time

In [ ]:

rng.integers(low=0, high=10, size=10)

Out[ ]:

array([8, 0, 7, 3, 5, 7, 2, 7, 8, 6], dtype=int64)

Số ngẫu nhiên từ phân phối thống kê

Với

def select(symbol_intervals,random):
        print symbol_intervals,random
        i = 0
        while random > symbol_intervals[i][1]:
                i += 1
                if i >= len(symbol_intervals):
                        raise Exception( "What did you DO to that poor list?" )
        return symbol_intervals[i][0]


def gen_random(alphabet,length,probabilities=None):
        from random import random
        from itertools import repeat
        if probabilities is None:
                probabilities = dict(zip(alphabet,repeat(1.0)))
        elif len(probabilities) > 0 and isinstance(probabilities[0],(int,long,float)):
                probabilities = dict(zip(alphabet,probabilities)) #ordered
        usable_probabilities = accumulate_normalize_values(probabilities)
        gen = []
        while len(gen) < length:
                gen.append(select(usable_probabilities,random()))
        return gen

>>> accumulate_normalize_values( { 'a': 100, 'b' : 300, 'c' : 400, 'd' : 200  } )
[('a', 0.1), ('c', 0.5), ('b', 0.8), ('d', 1.0)]

Hãy bắt đầu với một ví dụ bằng cách sử dụng phân phối bình thường tiêu chuẩn. Phân phối bình thường tiêu chuẩn chỉ đơn giản là phân phối bình thường với trung bình 0,0 và độ lệch chuẩn là 1.0.

Chúng ta có thể tạo ra một giá trị ngẫu nhiên duy nhất từ ​​phân phối bình thường tiêu chuẩn như sau.

Bây giờ, hãy để âm mưu phân phối một mẫu lớn hơn để thấy rằng nó tuân theo phân phối. Đầu tiên, nhập

>>> gen_random (['a','b','c','d'],10,[100,300,400,200])
['d', 'b', 'b', 'a', 'c', 'c', 'b', 'c', 'c', 'c']   #<--- some of the time

In [ ]:

>>> accumulate_normalize_values( { 'a': 100, 'b' : 300, 'c' : 400, 'd' : 200  } )
[('a', 0.1), ('c', 0.5), ('b', 0.8), ('d', 1.0)]

Hãy để tạo ra 1.000 số ngẫu nhiên từ phân phối bình thường tiêu chuẩn và vẽ biểu đồ.

In [ ]:

>>> accumulate_normalize_values( { 'a': 100, 'b' : 300, 'c' : 400, 'd' : 200  } )
[('a', 0.1), ('c', 0.5), ('b', 0.8), ('d', 1.0)]

Out[ ]:

>>> accumulate_normalize_values( { 'a': 100, 'b' : 300, 'c' : 400, 'd' : 200  } )
[('a', 0.1), ('c', 0.5), ('b', 0.8), ('d', 1.0)]

Như bạn có thể thấy, chúng tôi nhận được biểu đồ với phân phối bình thường tập trung ở mức 0,0. Để tạo các số ngẫu nhiên từ các phân phối khác, bạn chỉ cần chỉ định các tham số phân phối (thường là trung bình/trung tâm và phương sai). Tôi sẽ chứng minh với sự phân phối bình thường.

Ví dụ trước đã chứng minh phân phối bình thường tiêu chuẩn, được sử dụng rộng rãi. Nếu chúng ta muốn lấy các số ngẫu nhiên từ một phân phối bình thường với một giá trị trung bình và phương sai khác, chúng ta chỉ cần sử dụng hàm

>>> gen_random (['a','b','c','d'],10,[100,300,400,200])
['d', 'b', 'b', 'a', 'c', 'c', 'b', 'c', 'c', 'c']   #<--- some of the time

>>> gen_random (['a','b','c','d'],10,[100,300,400,200])
['d', 'b', 'b', 'a', 'c', 'c', 'b', 'c', 'c', 'c']   #<--- some of the time

In [ ]:

>>> accumulate_normalize_values( { 'a': 100, 'b' : 300, 'c' : 400, 'd' : 200  } )
[('a', 0.1), ('c', 0.5), ('b', 0.8), ('d', 1.0)]

Out[ ]:

>>> accumulate_normalize_values( { 'a': 100, 'b' : 300, 'c' : 400, 'd' : 200  } )
[('a', 0.1), ('c', 0.5), ('b', 0.8), ('d', 1.0)]

Hãy cùng làm một cuộc biểu tình nữa bằng cách sử dụng phân phối theo cấp số nhân. Phân phối theo cấp số nhân có một tham số tỷ lệ duy nhất. Chúng tôi sẽ chỉ định tham số tỷ lệ và tạo 10.000 giá trị ngẫu nhiên.

In [ ]:

>>> accumulate_normalize_values( { 'a': 100, 'b' : 300, 'c' : 400, 'd' : 200  } )
[('a', 0.1), ('c', 0.5), ('b', 0.8), ('d', 1.0)]

Out[ ]:

>>> accumulate_normalize_values( { 'a': 100, 'b' : 300, 'c' : 400, 'd' : 200  } )
[('a', 0.1), ('c', 0.5), ('b', 0.8), ('d', 1.0)]

Sự kết luận

Numpy cung cấp rất nhiều chức năng để tạo số ngẫu nhiên trong Python. Ngoài ra, nó là nhanh chóng và dễ sử dụng. Hướng dẫn này đã khám phá và chứng minh những điều cơ bản của việc tạo số ngẫu nhiên trong Python. Tiếp tục học và khám phá những ý tưởng này bằng cách phát triển các ứng dụng và dự án của riêng bạn!

Konrad Hafen

Konrad là một nhà khoa học tài nguyên thiên nhiên. Ông phát triển các mô hình và phân tích quy trình công việc để dự đoán và đánh giá các thay đổi đối với cảnh quan và tài nguyên nước.

Phân loại hình ảnh không giám sát với QGIS

Một hình ảnh phân chia trong đó nửa dưới hiển thị hình ảnh Landsat 9 với màu thật và hình ảnh trên cùng cho thấy kết quả phân loại không được giám sát. Phân loại hình ảnh là quá trình sử dụng số ...