यादृच्छिक संख्याओं का मैट्रिक्स बनाने का सरल तरीका

Question

मैं यादृच्छिक संख्याओं का एक मैट्रिक्स बनाने की कोशिश कर रहा हूं, लेकिन मेरा समाधान बहुत लंबा है और बदसूरत दिखता है

random_matrix = [[random.random() for e in range(2)] for e in range(3)]

यह ठीक लग रहा है, लेकिन मेरे कार्यान्वयन में यह है

weights_h = [[random.random() for e in range(len(inputs[0]))] for e in range(hiden_neurons)]

जो बेहद अपठनीय है और एक पंक्ति में फिट नहीं होता है।

Answer 1

Numpy.random.rand पर एक नज़र डालें :

डॉकस्ट्रिंग: रैंड (d0, d1, ..., dn)

किसी दिए गए आकार में यादृच्छिक मान।

दिए गए आकार की एक सरणी बनाएं और इसे एक समान वितरण पर यादृच्छिक नमूनों के साथ प्रचारित करें [0, 1)।

---

>>> import numpy as np
>>> np.random.rand(2,3)
array([[ 0.22568268,  0.0053246 ,  0.41282024],
       [ 0.68824936,  0.68086462,  0.6854153 ]])

Answer 2

आप इसे छोड़ सकते हैं range(len()):

weights_h = [[random.random() for e in inputs[0]] for e in range(hiden_neurons)]

लेकिन वास्तव में, आपको शायद खांसी का उपयोग करना चाहिए।

In [9]: numpy.random.random((3, 3))
Out[9]:
array([[ 0.37052381,  0.03463207,  0.10669077],
       [ 0.05862909,  0.8515325 ,  0.79809676],
       [ 0.43203632,  0.54633635,  0.09076408]])

Comments

कैसे यादृच्छिक ints पाने के लिए?

— जैक ट्वेन

numpy.random.random_integers(low, high, shape), उदाnumpy.random.random_integers(0, 100, (3, 3))

— बजे पावेल अनोसोस्वर

यादृच्छिक के हस्ताक्षर में दोहरे ब्रैकेट अंकन के लिए क्या शब्द है? मैं इससे परिचित नहीं हूं।

— एमिल विक्टर

@EmileVictor numpy.random.randomकई अन्य numpy.randomतरीकों की तरह आकृतियों को स्वीकार करता है, यानी N-tuples। तो वास्तव में बाहर के परांठे विधि को कॉल करने का प्रतिनिधित्व करते हैं numpy.random.random(), और अंदर के परांठे (3, 3)समारोह में पारित होने वाले टपल को तुरंत हटाने के लिए सिंटैक्टिक चीनी होते हैं ।

— विवेक झा

numpy.random.random_integers()पदावनत किया गया है। numpy.random.randint()इसके बजाय उपयोग करें । docs.scipy.org/doc/numpy/reference/generated/...

— Max

Answer 3

उपयोग के np.random.randint()रूप numpy.random.random_integers()में पदावनत किया जाता है

random_matrix = numpy.random.randint(min_val,max_val,(<num_rows>,<num_cols>))

Answer 4

लगता है कि आप कर्टेरा मशीन लर्निंग न्यूरल नेटवर्क व्यायाम का पायथन कार्यान्वयन कर रहे हैं। यहाँ मैंने क्या किया है randInitializeWeights (L_in, L_out) के लिए

#get a random array of floats between 0 and 1 as Pavel mentioned 
W = numpy.random.random((L_out, L_in +1))

#normalize so that it spans a range of twice epsilon
W = W * 2 * epsilon

#shift so that mean is at zero
W = W - epsilon

Answer 5

पहले numpyसरणी बनाएं, फिर उसे रूपांतरित करें matrix। नीचे दिए गए कोड को देखें:

import numpy

B = numpy.random.random((3, 4)) #its ndArray
C = numpy.matrix(B)# it is matrix
print(type(B))
print(type(C)) 
print(C)

Answer 6

x = np.int_(np.random.rand(10) * 10)

10 में से यादृच्छिक संख्याओं के लिए। 20 में से हमें 20 से गुणा करना होगा।

Answer 7

जब आप "यादृच्छिक संख्याओं का एक मैट्रिक्स" कहते हैं, तो आप Pavel https://stackoverflow.com/a/15451997/6169225 के रूप में numpy का उपयोग कर सकते हैं ऊपर उल्लिखित , इस मामले में मैं आपको मान रहा हूं कि यह अप्रासंगिक है कि ये वितरण क्या है (छद्म) ) यादृच्छिक संख्या का पालन करते हैं।

हालांकि, अगर आपको किसी विशेष वितरण की आवश्यकता है (मुझे लगता है कि आप समान वितरण में रुचि रखते हैं), numpy.randomआपके लिए बहुत उपयोगी तरीके हैं। उदाहरण के लिए, मान लें कि आप एक x2 मैट्रिक्स चाहते हैं जिसमें छद्म यादृच्छिक समरूप वितरण [निम्न, उच्च] से घिरा हो। आप ऐसा कर सकते हैं:

numpy.random.uniform(low,high,(3,2))

ध्यान दें, आप uniformइस पुस्तकालय द्वारा समर्थित किसी भी वितरण को बदल सकते हैं ।

आगे पढ़े: https://docs.scipy.org/doc/numpy/reference/routines.random.html

Answer 8

यादृच्छिक पूर्णांकों की एक सरणी बनाने का एक सरल तरीका है:

matrix = np.random.randint(maxVal, size=(rows, columns))

निम्नलिखित 0 से 10 तक यादृच्छिक पूर्णांक के 3 मैट्रिक्स द्वारा 2 आउटपुट करता है:

a = np.random.randint(10, size=(2,3))

Answer 9

यादृच्छिक संख्याओं की एक सरणी बनाने के लिए NumPy उपयोग करके सरणी निर्माण प्रदान करता है:

1. वास्तविक संख्याये

2. पूर्णांकों

यादृच्छिक वास्तविक संख्याओं का उपयोग करके सरणी बनाने के लिए : 2 विकल्प हैं

1. random.rand (उत्पन्न यादृच्छिक संख्या के समान वितरण के लिए)
2. random.randn (उत्पन्न यादृच्छिक संख्या के सामान्य वितरण के लिए)

random.rand

import numpy as np 
arr = np.random.rand(row_size, column_size) 

random.randn

import numpy as np 
arr = np.random.randn(row_size, column_size) 

यादृच्छिक पूर्णांक का उपयोग करके सरणी बनाने के लिए :

import numpy as np
numpy.random.randint(low, high=None, size=None, dtype='l')

कहाँ पे

• कम = सबसे कम (हस्ताक्षरित) पूर्णांक वितरण से निकाला जाना
• उच्च (वैकल्पिक) = यदि प्रदान किया गया है, तो वितरण से प्राप्त किए जाने वाले सबसे बड़े (हस्ताक्षरित) पूर्णांक के ऊपर एक
• आकार (वैकल्पिक) = आउटपुट आकार अर्थात यदि दी गई आकृति है, जैसे, (m, n, k), तो m * n * नमूने खींचे गए हैं
• dtype (वैकल्पिक) = परिणाम का वांछित प्रारूप।

उदाहरण के लिए:

दिए गए उदाहरण 0 और 4 के बीच यादृच्छिक पूर्णांक की एक सरणी का उत्पादन करेंगे, इसका आकार 5 * 5 होगा और इसमें 25 पूर्णांक होंगे

arr2 = np.random.randint(0,5,size = (5,5))

5 से 5 मैट्रिक्स बनाने के लिए, इसे संशोधित किया जाना चाहिए

arr2 = np.random.randint (0,5, size = (5,5)), गुणन चिह्न को * अल्पविराम में बदलें, #

[[२ १ १ १ ० १] [३ २ १ १ ४ ३] [२ ३ ० ३ ३] [१ ३ १ ० ०] [४ ३ २ २ १]]

eg2:

दिए गए उदाहरण 0 और 1 के बीच यादृच्छिक पूर्णांक की एक सरणी का उत्पादन करेंगे, इसका आकार 1 * 10 होगा और इसमें 10 पूर्णांक होंगे

arr3= np.random.randint(2, size = 10)

[० ० ० १ १ १ ० ० १]

Answer 10

random_matrix = [[random.random for j in range(collumns)] for i in range(rows)
for i in range(rows):
    print random_matrix[i]

Answer 11

मानचित्र-कम का उपयोग कर एक उत्तर: -

map(lambda x: map(lambda y: ran(),range(len(inputs[0]))),range(hiden_neurons))

Answer 12

#this is a function for a square matrix so on the while loop rows does not have to be less than cols.
#you can make your own condition. But if you want your a square matrix, use this code.

import random

import numpy as np

def random_matrix(R, cols):

        matrix = []

        rows =  0

        while  rows < cols:

            N = random.sample(R, cols)

            matrix.append(N)

            rows = rows + 1

    return np.array(matrix)

print(random_matrix(range(10), 5))
#make sure you understand the function random.sample

Answer 13

numpy.random.rand (पंक्ति, स्तंभ) दिए गए निर्दिष्ट (एम, एन) मापदंडों के अनुसार, 0 और 1 के बीच यादृच्छिक संख्या उत्पन्न करता है। तो एक (एम, एन) मैट्रिक्स बनाने के लिए इसका उपयोग करें और सीमा सीमा के लिए मैट्रिक्स को गुणा करें और इसे उच्च सीमा के साथ योग करें।

विश्लेषण: यदि शून्य उत्पन्न होता है, तो कम सीमा आयोजित की जाएगी, लेकिन यदि कोई उत्पन्न होता है तो उच्च सीमा आयोजित की जाएगी। आदेश शब्दों में, रैंड सुपी का उपयोग करके सीमाएं उत्पन्न करने से आप अत्यधिक वांछित संख्या उत्पन्न कर सकते हैं।

import numpy as np

high = 10
low = 5
m,n = 2,2

a = (high - low)*np.random.rand(m,n) + low

आउटपुट:

a = array([[5.91580065, 8.1117106 ],
          [6.30986984, 5.720437  ]])