-1 का क्या मतलब है?

Question

पैरामीटर -1 के साथ रेज़ैप फ़ंक्शन का उपयोग करके एक खस्ता मैट्रिक्स को वेक्टर में फिर से आकार दिया जा सकता है। लेकिन मुझे नहीं पता कि यहां -1 का क्या मतलब है।

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

a = numpy.matrix([[1, 2, 3, 4], [5, 6, 7, 8]])
b = numpy.reshape(a, -1)

का परिणाम bहै:matrix([[1, 2, 3, 4, 5, 6, 7, 8]])

क्या किसी को पता है -1 का मतलब क्या है? और ऐसा लगता है कि अजगर ने -1 कई अर्थ दिए हैं, जैसे: array[-1]अंतिम तत्व। क्या आप स्पष्टीकरण दे सकते हैं?

Answer 1

नई आकृति प्रदान करने के लिए संतुष्ट करने की कसौटी यह है कि 'नई आकृति मूल आकृति के अनुकूल होनी चाहिए'

numpy हमें 1 के रूप में नए आकार के पैरामीटर देने की अनुमति देता है (जैसे: (2, -1) या (-1,3) लेकिन नहीं (-1, -1)। इसका सीधा सा मतलब है कि यह एक अनजान आयाम है और हम चाहते हैं कि इसे समझ लिया जाए। और सुन्न 'सरणी की लंबाई और शेष आयामों' को देखकर यह सुनिश्चित करेगा कि यह उपर्युक्त मानदंडों को पूरा करता है

अब उदाहरण देखें।

z = np.array([[1, 2, 3, 4],
         [5, 6, 7, 8],
         [9, 10, 11, 12]])
z.shape
(3, 4)

अब (-1) के साथ फेरबदल करने की कोशिश कर रहा है। परिणाम नई आकृति है (12,) और मूल आकार के साथ संगत है (3,4)

z.reshape(-1)
array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12])

अब (-1, 1) के साथ फेरबदल करने की कोशिश कर रहा है। हमने कॉलम को 1 लेकिन पंक्तियों को अज्ञात के रूप में प्रदान किया है। इसलिए हमें परिणाम (12, 1) के रूप में नए आकार मिलते हैं। मूल आकार (3,4) के साथ संगत।

z.reshape(-1,1)
array([[ 1],
   [ 2],
   [ 3],
   [ 4],
   [ 5],
   [ 6],
   [ 7],
   [ 8],
   [ 9],
   [10],
   [11],
   [12]])

उपरोक्त एकल सुविधा के numpyलिए उपयोग करने के reshape(-1,1)लिए सलाह / त्रुटि संदेश के अनुरूप है ; यानी सिंगल कॉलम

array.reshape(-1, 1)यदि आपके डेटा में एकल सुविधा है, तो अपने डेटा का उपयोग करके उसे रीसेट करें

नई आकृति (-1, 2) के रूप में। पंक्ति अज्ञात, कॉलम 2। हमें नए आकार में परिणाम मिलता है (6, 2)

z.reshape(-1, 2)
array([[ 1,  2],
   [ 3,  4],
   [ 5,  6],
   [ 7,  8],
   [ 9, 10],
   [11, 12]])

अब कॉलम को अज्ञात के रूप में रखने का प्रयास किया जा रहा है। नई आकृति (1, -1) के रूप में। यानी, पंक्ति 1, कॉलम अज्ञात है। हम परिणाम के रूप में नए आकार (1, 12)

z.reshape(1,-1)
array([[ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12]])

उपरोक्त एक ही नमूने के numpyलिए उपयोग करने के reshape(1,-1)लिए सलाह / त्रुटि संदेश के अनुरूप है ; यानी एकल पंक्ति

array.reshape(1, -1)यदि यह एकल नमूना है तो अपने डेटा का उपयोग करके उसे फिर से खोलें

नया आकार (2, -1)। पंक्ति 2, कॉलम अज्ञात। हम परिणाम के रूप में नए आकार (2,6)

z.reshape(2, -1)
array([[ 1,  2,  3,  4,  5,  6],
   [ 7,  8,  9, 10, 11, 12]])

नई आकृति (3, -1) के रूप में। पंक्ति 3, कॉलम अज्ञात। हम परिणाम के रूप में नए आकार (3,4)

z.reshape(3, -1)
array([[ 1,  2,  3,  4],
   [ 5,  6,  7,  8],
   [ 9, 10, 11, 12]])

और अंत में, यदि हम दोनों आयामों को अज्ञात यानी नए आकार के रूप में (-1, -1) प्रदान करने का प्रयास करते हैं। यह एक त्रुटि फेंक देगा

z.reshape(-1, -1)
ValueError: can only specify one unknown dimension

Comments

इस उत्तर में बहुत सारे उदाहरण हैं, लेकिन सादे अंग्रेजी में -1 क्या नहीं करता है। किसी सरणी को पुन: आकार देते समय, नए आकार में पुराने आकार के समान तत्व होने चाहिए, अर्थात दो आकार के आयामों के उत्पाद समान होने चाहिए। -1 का उपयोग करते समय, -1 से संबंधित आयाम मूल सरणी के आयामों का उत्पाद होगा, जो कि दिए गए आयामों के उत्पाद द्वारा विभाजित किया जाएगा reshapeताकि तत्वों की समान संख्या को बनाए रखा जा सके।

— बॉलपॉइंटबैन

मेरी राय में स्वीकृत उत्तर और यह उत्तर दोनों ही सहायक हैं, जबकि स्वीकृत उत्तर अधिक सरल है, मैं सरल उत्तर पसंद करता हूं

— बादलों की संख्या

आकृति (12, 1) आकार (3,4) के साथ "संगत" कैसे है?

— विजेंद्र

@Vijender मुझे लगता है कि इसका मतलब तत्वों की समान संख्या लेकिन विभिन्न अक्ष - यानी 12x1 == 3x4 है?

— डेविड वाटरवर्थ

Answer 2

एक सरणी को फिर से व्यवस्थित करने के लिए उपयोग किया जाता है।

मान लें कि हमारे पास 3 आयामी आयाम हैं 2 x 10 x 10:

r = numpy.random.rand(2, 10, 10) 

अब हम 5 X 5 x 8 पर फिर से क्लिक करना चाहते हैं:

numpy.reshape(r, shape=(5, 5, 8)) 

नौकरी करेंगे।

ध्यान दें, एक बार जब आप पहले मंद = 5 और दूसरे मंद = 5 को ठीक करते हैं, तो आपको तीसरे आयाम को निर्धारित करने की आवश्यकता नहीं होती है। अपने आलस्य की सहायता के लिए, अजगर -1 का विकल्प देता है:

numpy.reshape(r, shape=(5, 5, -1)) 

आपको एक आकृति प्रदान करेगा = (5, 5, 8)।

इसी तरह,

numpy.reshape(r, shape=(50, -1)) 

आपको आकृति का एक सरणी देगा = (50, 4)

आप http://anie.me/numpy-reshape-transpose-theano-dimadufff/ पर अधिक पढ़ सकते हैं

Answer 3

के अनुसार the documentation:

न्यूज़हैप: इन्ट्स का इंट या ट्यूपल

नया आकार मूल आकार के साथ संगत होना चाहिए। यदि एक पूर्णांक, तो परिणाम उस लंबाई का 1-डी सरणी होगा। एक आकार का आयाम -1 हो सकता है । इस स्थिति में, मान सरणी की लंबाई और शेष आयामों से अनुमानित है।

Comments

इस स्थिति में, मान [1, 8] होने का अनुमान है। और 8 मैट्रिक्स की कुल संख्या है a। सही?

— user2262504

@ user2262504, मुझे यकीन नहीं है। मुझे लगता है कि मान का अनुमान [8]इसलिए है क्योंकि प्रलेखन ऐसा कहता है ( 1-D array)। कोशिश करो numpy.reshape(a, [8])। यह numpy.reshape(a, [1,8])मैट्रिक्स के लिए समान परिणाम देता है।

— falsetru

-1 परिणामी मैट्रिक्स में आपके लिए अज्ञात संख्या में कॉलम या पंक्तियों को निर्धारित करने की सुविधा देता है। नोट: अज्ञात में कॉलम या रो दोनों होने चाहिए, दोनों नहीं।

— गैथाइड

Answer 4

numpy.reshape (a, newshape, order {}) अधिक जानकारी के लिए नीचे दिए गए लिंक की जाँच करें। https://docs.scipy.org/doc/numpy/reference/generated/numpy.reshape.html

नीचे दिए गए उदाहरण के लिए आपने आउटपुट का उल्लेख किया है परिणामी वेक्टर को एक पंक्ति कहा जाता है। (- 1) पंक्तियों की संख्या को 1. 1 करने के लिए इंगित करता है।

a = numpy.matrix([[1, 2, 3, 4], [5, 6, 7, 8]])
b = numpy.reshape(a, -1)

उत्पादन:

मैट्रिक्स ([[१, २, ३, ४, ५, ६,,,)]]]

यह एक और उदाहरण के साथ और अधिक सटीक रूप से समझाया जा सकता है:

b = np.arange(10).reshape((-1,1))

आउटपुट: (एक 1 आयामी स्तंभ सरणी है)

सरणी ([[0],

   [1],
   [2],
   [3],
   [4],
   [5],
   [6],
   [7],
   [8],
   [9]])

b = np.arange (10) .reshape (1, -1)

आउटपुट: (एक आयामी पंक्ति सरणी है)

सरणी ([[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]])

Answer 5

इसे समझना काफी आसान है। "-1" का अर्थ "अज्ञात आयाम" है जो दूसरे आयाम से अनुमानित होना चाहिए। इस मामले में, यदि आप अपना मैट्रिक्स इस तरह सेट करते हैं:

a = numpy.matrix([[1, 2, 3, 4], [5, 6, 7, 8]])

अपने मैट्रिक्स को इस तरह संशोधित करें:

b = numpy.reshape(a, -1)

यह मैट्रिक्स ए के लिए कुछ बहरे संचालन को कॉल करेगा, जो 1-डी सुपीरियर सरणी / मार्टरिक्स लौटाएगा।

हालाँकि, मुझे नहीं लगता कि इस तरह कोड का उपयोग करना एक अच्छा विचार है। क्यों नहीं कोशिश करो:

b = a.reshape(1,-1)

यह आपको एक ही परिणाम देगा और पाठकों के लिए यह समझना अधिक स्पष्ट है: b को a के दूसरे आकार के रूप में सेट करें। एक के लिए, हमारे पास कितने कॉलम नहीं होने चाहिए (इसे -1 पर सेट करें!), लेकिन हम 1-आयाम वाला सरणी चाहते हैं (पहले पैरामीटर को 1 पर सेट करें!)।

Answer 6

छोटी कहानी : आप कुछ आयाम निर्धारित करते हैं और NumPy को शेष सेट करते हैं।

(userDim1, userDim2, ..., -1) -->>

(userDim1, userDim1, ..., TOTAL_DIMENSION - (userDim1 + userDim2 + ...))

Comments

यह अंग्रेजी में उत्तर है जो मैं देख रहा था, सादा और सरल। यानी आप अपने डिजाइन को तरजीह देते हैं, शेष गणित को सुन्न करने दें :)

— सुमंत लाजर

Answer 7

इसका सीधा सा मतलब है कि आप इस बारे में निश्चित नहीं हैं कि आप कितनी संख्या में पंक्तियों या स्तंभों को दे सकते हैं और आप स्तब्ध होकर संख्याओं या पंक्तियों की संख्या सुझाने के लिए कह रहे हैं।

numpy -1 https://docs.scipy.org/doc/numpy/reference/generated/numpy.reshape.html के लिए अंतिम उदाहरण प्रदान करता है

नीचे दिए गए कोड और इसके आउटपुट को बेहतर तरीके से समझने के लिए (-1):

कोड: -

import numpy
a = numpy.matrix([[1, 2, 3, 4], [5, 6, 7, 8]])
print("Without reshaping  -> ")
print(a)
b = numpy.reshape(a, -1)
print("HERE We don't know about what number we should give to row/col")
print("Reshaping as (a,-1)")
print(b)
c = numpy.reshape(a, (-1,2))
print("HERE We just know about number of columns")
print("Reshaping as (a,(-1,2))")
print(c)
d = numpy.reshape(a, (2,-1))
print("HERE We just know about number of rows")
print("Reshaping as (a,(2,-1))")
print(d)

OUTPUT: -

Without reshaping  -> 
[[1 2 3 4]
 [5 6 7 8]]
HERE We don't know about what number we should give to row/col
Reshaping as (a,-1)
[[1 2 3 4 5 6 7 8]]
HERE We just know about number of columns
Reshaping as (a,(-1,2))
[[1 2]
 [3 4]
 [5 6]
 [7 8]]
HERE We just know about number of rows
Reshaping as (a,(2,-1))
[[1 2 3 4]
 [5 6 7 8]]

Answer 8

import numpy as np
x = np.array([[2,3,4], [5,6,7]]) 

# Convert any shape to 1D shape
x = np.reshape(x, (-1)) # Making it 1 row -> (6,)

# When you don't care about rows and just want to fix number of columns
x = np.reshape(x, (-1, 1)) # Making it 1 column -> (6, 1)
x = np.reshape(x, (-1, 2)) # Making it 2 column -> (3, 2)
x = np.reshape(x, (-1, 3)) # Making it 3 column -> (2, 3)

# When you don't care about columns and just want to fix number of rows
x = np.reshape(x, (1, -1)) # Making it 1 row -> (1, 6)
x = np.reshape(x, (2, -1)) # Making it 2 row -> (2, 3)
x = np.reshape(x, (3, -1)) # Making it 3 row -> (3, 2)

Answer 9

रूपांतरण का अंतिम परिणाम यह है कि अंतिम सरणी में तत्वों की संख्या प्रारंभिक सरणी या डेटा फ़्रेम के समान है।

-1 पंक्ति या स्तंभ की अज्ञात संख्या से मेल खाती है। हम इसे x(अज्ञात) के रूप में सोच सकते हैं । x-1 के साथ आदेशित जोड़ी के अन्य मूल्य द्वारा मूल सरणी में तत्वों के umber को विभाजित करके प्राप्त किया जाता है।

उदाहरण

Reshape (-1,1) के साथ 12 तत्व x= 12/1 = 12 पंक्तियों और 1 कॉलम के साथ एक सरणी से मेल खाते हैं ।

12 तत्वों के साथ reshape (1, -1) 1 पंक्ति और x= 12/1 = 12 कॉलम के साथ एक सरणी से मेल खाती है ।