एकतरफा में दो सुन्न सरणियों को फेरने का बेहतर तरीका

Question

मेरे पास अलग-अलग आकृतियों के दो सुन्न सरणियां हैं, लेकिन एक ही लंबाई (अग्रणी आयाम) के साथ। मैं उनमें से प्रत्येक को फेरबदल करना चाहता हूं, जैसे कि संबंधित तत्व पत्र-व्यवहार करते रहते हैं - अर्थात उन्हें अपने प्रमुख मसलों के संबंध में एकजुट करना चाहिए।

यह कोड काम करता है, और मेरे लक्ष्यों को दिखाता है:

def shuffle_in_unison(a, b):
    assert len(a) == len(b)
    shuffled_a = numpy.empty(a.shape, dtype=a.dtype)
    shuffled_b = numpy.empty(b.shape, dtype=b.dtype)
    permutation = numpy.random.permutation(len(a))
    for old_index, new_index in enumerate(permutation):
        shuffled_a[new_index] = a[old_index]
        shuffled_b[new_index] = b[old_index]
    return shuffled_a, shuffled_b

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

>>> a = numpy.asarray([[1, 1], [2, 2], [3, 3]])
>>> b = numpy.asarray([1, 2, 3])
>>> shuffle_in_unison(a, b)
(array([[2, 2],
       [1, 1],
       [3, 3]]), array([2, 1, 3]))

हालाँकि, यह स्पष्ट, अक्षम और धीमा लगता है, और इसमें सरणियों की एक प्रतिलिपि बनाने की आवश्यकता होती है - मैं उन्हें जगह में फेरबदल करना चाहता हूं, क्योंकि वे काफी बड़े होंगे।

क्या इस बारे में जाने का कोई बेहतर तरीका है? तेज़ निष्पादन और कम मेमोरी उपयोग मेरे प्राथमिक लक्ष्य हैं, लेकिन सुरुचिपूर्ण कोड भी अच्छा होगा।

एक अन्य विचार मुझे यह था:

def shuffle_in_unison_scary(a, b):
    rng_state = numpy.random.get_state()
    numpy.random.shuffle(a)
    numpy.random.set_state(rng_state)
    numpy.random.shuffle(b)

यह काम करता है ... लेकिन यह थोड़ा डरावना है, क्योंकि मैं थोड़ा गारंटी देता हूं कि यह काम करना जारी रखेगा - यह उस तरह का नहीं दिखता है जो उदाहरण के लिए, खस्ता संस्करण में जीवित रहने की गारंटी है।

Comments

छह साल बाद, मैं हैरान और हैरान हूं कि यह सवाल कितना लोकप्रिय साबित हुआ। और कुछ हर्षजनक संयोग के लिए, गो 1.10 के लिए मैंने गणित / रैंड का योगदान दिया । मानक पुस्तकालय में फेरबदल करें । एपीआई के डिजाइन ने एकरूपता में दो सरणियों को फेरना तुच्छ बना दिया है, और ऐसा करना डॉक्स में एक उदाहरण के रूप में भी शामिल है।

— जोश ब्लेकर स्नाइडर

Answer 1

आपका "डरावना" समाधान मुझे डरावना नहीं लगता। कॉलिंग shuffle()यादृच्छिक संख्या जनरेटर के लिए कॉल के एक ही नंबर में एक ही लंबाई परिणामों के दो दृश्यों के लिए, और इन फेरबदल एल्गोरिथ्म में केवल "यादृच्छिक" तत्व हैं। राज्य को रीसेट करके, आप यह सुनिश्चित करते हैं कि रैंडम नंबर जनरेटर को कॉल दूसरी कॉल में समान परिणाम देगा shuffle(), इसलिए संपूर्ण एल्गोरिथ्म एक ही क्रमचय उत्पन्न करेगा।

यदि आपको यह पसंद नहीं है, तो एक अलग समाधान आपके डेटा को शुरुआत से दो अधिकार के बजाय एक सरणी में संग्रहीत करने के लिए होगा, और अब आपके पास मौजूद दो सरणियों का अनुकरण करते हुए इस एकल सरणी में दो दृश्य बनाएं। आप फेरबदल के लिए एकल सरणी और अन्य सभी उद्देश्यों के लिए विचारों का उपयोग कर सकते हैं।

उदाहरण: आइए सरणियों को मानें aऔर bइस तरह देखें:

a = numpy.array([[[  0.,   1.,   2.],
                  [  3.,   4.,   5.]],

                 [[  6.,   7.,   8.],
                  [  9.,  10.,  11.]],

                 [[ 12.,  13.,  14.],
                  [ 15.,  16.,  17.]]])

b = numpy.array([[ 0.,  1.],
                 [ 2.,  3.],
                 [ 4.,  5.]])

अब हम एक एकल सरणी का निर्माण कर सकते हैं जिसमें सभी डेटा हैं:

c = numpy.c_[a.reshape(len(a), -1), b.reshape(len(b), -1)]
# array([[  0.,   1.,   2.,   3.,   4.,   5.,   0.,   1.],
#        [  6.,   7.,   8.,   9.,  10.,  11.,   2.,   3.],
#        [ 12.,  13.,  14.,  15.,  16.,  17.,   4.,   5.]])

अब हम मूल के अनुकरण के विचार बनाते हैं aऔर b:

a2 = c[:, :a.size//len(a)].reshape(a.shape)
b2 = c[:, a.size//len(a):].reshape(b.shape)

के डेटा a2और b2के साथ साझा किया c। एक साथ दोनों सरणियों में फेरबदल करने के लिए, का उपयोग करें numpy.random.shuffle(c)।

उत्पादन कोड में, आप निश्चित रूप से मूल aऔर बिल्कुल बनाने से बचने की कोशिश करेंगे bऔर तुरंत निर्माण करें c, a2और b2।

इस समाधान को उस मामले के लिए अनुकूलित किया जा सकता है जो aऔर bअलग-अलग dtypes हैं।

Comments

पुन: डरावना समाधान: मुझे बस यह चिंता है कि विभिन्न आकृतियों के सरणियाँ (बोधगम्य) विभिन्न प्रकार की कॉल को rng पर ला सकती हैं, जो कि विचलन का कारण बनेंगी। हालाँकि, मुझे लगता है कि आप सही हैं कि वर्तमान व्यवहार शायद बदलने की संभावना नहीं है, और एक बहुत ही सरल सिद्धांत सही व्यवहार की पुष्टि करना बहुत आसान बनाता है ...

— जोश ब्लेचर स्नाइडर

मुझे आपके सुझाए गए दृष्टिकोण पसंद हैं, और निश्चित रूप से एकीकृत सी सरणी के रूप में बी और बी शुरू करने की व्यवस्था कर सकते हैं। हालांकि, ए और बी को फेरबदल के बाद जल्द ही सन्निहित होने की आवश्यकता होगी (एक GPU के लिए कुशल हस्तांतरण के लिए), इसलिए मुझे लगता है कि, मेरे विशेष मामले में, मैं वैसे भी और बी की प्रतियां बनाना चाहूंगा। :(

— जोश ब्लेकर स्नाइडर

@ जोश: ध्यान दें कि numpy.random.shuffle()मनमाने ढंग से परिवर्तनशील अनुक्रमों पर काम करता है, जैसे कि पायथन सूची या न्यूमपी सरणियाँ। सरणी आकार कोई फर्क नहीं पड़ता, केवल अनुक्रम की लंबाई। यह वह जगह है बहुत मेरी राय में परिवर्तन की संभावना नहीं।

— स्वेन मार्नाच

मुझे नहीं पता था। यह मुझे इसके साथ बहुत अधिक आरामदायक बनाता है। धन्यवाद।

— जोश ब्लीचर स्नाइडर

@SvenMarnach: मैंने नीचे एक उत्तर पोस्ट किया है। क्या आप इस पर टिप्पणी कर सकते हैं कि क्या आपको लगता है कि यह समझ में आता है / इसे करने का एक अच्छा तरीका है?

— ajfbiw.s

Answer 2

आप NumPy के सरणी अनुक्रमण का उपयोग कर सकते हैं :

def unison_shuffled_copies(a, b):
    assert len(a) == len(b)
    p = numpy.random.permutation(len(a))
    return a[p], b[p]

इसके परिणामस्वरूप अलग-अलग जेल-फेरबदल सरणियों का निर्माण होगा।

Comments

यह करता है , प्रतिलिपि बनाने के रूप में यह उन्नत अनुक्रमण उपयोग करता है। लेकिन निश्चित रूप से यह मूल से तेज है।

— स्वेन मार्नाच

@mtrw: मूल सरणियाँ अछूता होने का मात्र तथ्य यह नहीं है कि लौटे हुए सरणियाँ समान डेटा के दृश्य हैं। लेकिन वे वास्तव में नहीं हैं, क्योंकि NumPy विचार अनुमत विचारों का समर्थन करने के लिए पर्याप्त लचीले नहीं हैं (यह या तो वांछनीय नहीं होगा)।

— स्वेन मार्नाच

@ स्वेन - मुझे वास्तव में विचारों के बारे में सीखना है। @ डैट चू - मैंने अभी-अभी कोशिश की >>> t = timeit.Timer(stmt = "<function>(a,b)", setup = "import numpy as np; a,b = np.arange(4), np.arange(4*20).reshape((4,20))")>>> t.timeit()और ओपी के संस्करण के लिए 38 सेकंड और मेरा 1 मिलियन कॉल के लिए 27.5 सेकंड का समय मिला।

— ०५:११

मुझे वास्तव में इस की सादगी और पठनीयता पसंद है, और उन्नत अनुक्रमण मुझे आश्चर्यचकित और विस्मित करना जारी रखता है; इसके लिए यह उत्तर आसानी से +1 हो जाता है। विचित्र रूप से पर्याप्त है, हालांकि, मेरे (बड़े) डेटासेट पर, यह मेरे मूल फ़ंक्शन की तुलना में धीमा है: मेरा मूल 10 पुनरावृत्तियों के लिए ~ 1.8s लेता है, और यह ~ 2.7s लेता है। दोनों संख्या काफी सुसंगत हैं। मेरे द्वारा उपयोग किया गया डेटासेट a.shapeहै (31925, 405)और b.shapeहै (31925,)।

— जोश बिलीचर स्नाइडर

हो सकता है, धीमापन का इस बात से कोई लेना-देना नहीं है कि आप चीजों को अंदर नहीं कर रहे हैं, बल्कि नए ऐरे बना रहे हैं। या CPython कैसे सरणी-अनुक्रमित करता है से संबंधित कुछ सुस्ती के साथ।

— 08होर मे

Answer 3

X = np.array([[1., 0.], [2., 1.], [0., 0.]])
y = np.array([0, 1, 2])
from sklearn.utils import shuffle
X, y = shuffle(X, y, random_state=0)

अधिक जानने के लिए, http://scikit-learn.org/stable/modules/generated/sklearn.utils.shuffle.html देखें

Comments

यह समाधान प्रतियां बनाता है ( "मूल सरणियाँ प्रभावित नहीं होती हैं" ), जबकि लेखक का "डरावना" समाधान नहीं करता है।

— बारतोलो-ओटिट

आप अपनी पसंद के अनुसार कोई भी स्टाइल चुन सकते हैं

— जेम्स

Answer 4

बहुत ही सरल उपाय:

randomize = np.arange(len(x))
np.random.shuffle(randomize)
x = x[randomize]
y = y[randomize]

दो सरणियों x, y अब दोनों एक ही तरीके से बेतरतीब ढंग से फेरबदल कर रहे हैं

Comments

यह mtrw के समाधान के बराबर है। आपकी पहली दो पंक्तियाँ सिर्फ एक क्रमचय उत्पन्न कर रही हैं, लेकिन यह एक पंक्ति में की जा सकती है।

— जोश ब्लीचर स्नाइडर

Answer 5

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

X = np.array([[1., 0.], [2., 1.], [0., 0.]])
y = np.array([0, 1, 2])
from sklearn.utils import shuffle
X, y = shuffle(X, y)

Answer 6

from np.random import permutation
from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data #numpy array
y = iris.target #numpy array

# Data is currently unshuffled; we should shuffle 
# each X[i] with its corresponding y[i]
perm = permutation(len(X))
X = X[perm]
y = y[perm]

Answer 7

केवल NumPy का उपयोग करके, किसी भी स्थान पर एक साथ, किसी भी संख्या में फेरबदल करें।

import numpy as np


def shuffle_arrays(arrays, set_seed=-1):
    """Shuffles arrays in-place, in the same order, along axis=0

    Parameters:
    -----------
    arrays : List of NumPy arrays.
    set_seed : Seed value if int >= 0, else seed is random.
    """
    assert all(len(arr) == len(arrays[0]) for arr in arrays)
    seed = np.random.randint(0, 2**(32 - 1) - 1) if set_seed < 0 else set_seed

    for arr in arrays:
        rstate = np.random.RandomState(seed)
        rstate.shuffle(arr)

और इस तरह इस्तेमाल किया जा सकता है

a = np.array([1, 2, 3, 4, 5])
b = np.array([10,20,30,40,50])
c = np.array([[1,10,11], [2,20,22], [3,30,33], [4,40,44], [5,50,55]])

shuffle_arrays([a, b, c])

ध्यान देने योग्य कुछ बातें:

• मुखर यह सुनिश्चित करता है कि सभी इनपुट सरणियों की लंबाई उनके पहले आयाम के समान है।
• अपने पहले आयाम से जगह-जगह फेरबदल किया - कुछ भी नहीं लौटा।
• सकारात्मक int32 रेंज के भीतर यादृच्छिक बीज।
• यदि एक दोहराए जाने वाले फेरबदल की आवश्यकता होती है, तो बीज का मूल्य निर्धारित किया जा सकता है।

फेरबदल के बाद, डेटा को np.splitस्लाइस का उपयोग करके या संदर्भित करके विभाजित किया जा सकता है - आवेदन पर निर्भर करता है।

Comments

सुंदर समाधान, यह मेरे लिए एकदम सही काम किया। 3+ अक्ष के सरणियों के साथ भी

— wprins

यह सही जवाब है। जब आप यादृच्छिक राज्य वस्तुओं के आसपास से गुजर सकते हैं तो वैश्विक np.random का उपयोग करने का कोई कारण नहीं है।

— कामुक

एक RandomStateलूप के बाहर इस्तेमाल किया जा सकता है। एडम स्नैडर का उत्तर

— बार्टोलो-ओट्री

@ बार्टोलो-ओट्री, जिस विकल्प को forलूप में बनाया जाना है वह यह है कि यादृच्छिक स्थिति को पुन: असाइन या फिर से करें। एक छोटे से होने की उम्मीद में फेरबदल समारोह में पारित होने की संख्या के साथ, मैं दोनों के बीच प्रदर्शन के अंतर की उम्मीद नहीं करूंगा। लेकिन हां, रैस्टेट को लूप के बाहर सौंपा जा सकता है और प्रत्येक पुनरावृत्ति पर लूप के अंदर फिर से बनाया जा सकता है।

— आइजैक बी

Answer 8

आप एक सरणी बना सकते हैं जैसे:

s = np.arange(0, len(a), 1)

फिर इसे फेरबदल करें:

np.random.shuffle(s)

अब अपने सरणियों के तर्क के रूप में इस का उपयोग करें। समान फेरबदल वाले तर्क एक ही फेरबदल वाले वैक्टर को वापस करते हैं।

x_data = x_data[s]
x_label = x_label[s]

Comments

वास्तव में, यह सबसे अच्छा समाधान है, और इसे स्वीकार किया जाना चाहिए! यह एक ही समय में कई (2 से अधिक) सरणियों के लिए भी काम करता है। यह विचार सरल है: बस सूची सूची को फेरबदल करें [0, 1, 2, ..., n-1], और फिर फेरबदल अनुक्रमित के साथ सरणियों की पंक्तियों को फिर से लिखना। अच्छा!

— बसज

Answer 9

कनेक्टेड सूचियों के लिए इन-प्लेस फेरबदल का एक तरीका बीज का उपयोग करना है (यह यादृच्छिक हो सकता है) और फेरबदल करने के लिए numpy.random.shuffle का उपयोग कर रहा है।

# Set seed to a random number if you want the shuffling to be non-deterministic.
def shuffle(a, b, seed):
   np.random.seed(seed)
   np.random.shuffle(a)
   np.random.seed(seed)
   np.random.shuffle(b)

बस। यह ए और बी दोनों को समान रूप से फेरबदल करेगा। यह इन-प्लेस भी किया जाता है जो हमेशा एक प्लस होता है।

EDIT, इसके बजाय np.random.seed () np.random.RandomState का उपयोग न करें

def shuffle(a, b, seed):
   rand_state = np.random.RandomState(seed)
   rand_state.shuffle(a)
   rand_state.seed(seed)
   rand_state.shuffle(b)

जब यह कहते हैं तो किसी भी बीज को यादृच्छिक अवस्था में खिलाने के लिए पास करें:

a = [1,2,3,4]
b = [11, 22, 33, 44]
shuffle(a, b, 12345)

आउटपुट:

>>> a
[1, 4, 2, 3]
>>> b
[11, 44, 22, 33]

संपादित करें: यादृच्छिक राज्य को फिर से बीज करने के लिए निश्चित कोड

Comments

यह कोड काम नहीं करता है। RandomStateपहली कॉल पर स्थिति बदल जाती है aऔर bएकसमान में फेरबदल नहीं किया जाता है।

— ब्रूनो क्लेन

@BrunoKlein आप सही हैं। मैंने रैंडम स्टेट को री-सीड करने के लिए पोस्ट को ठीक किया। इसके अलावा, भले ही यह एक ही समय में दोनों सूचियों के फेरबदल में एक समान नहीं है, लेकिन वे इस अर्थ में एकसमान हैं कि दोनों को एक ही तरह से फेरबदल किया जाता है, और इसे धारण करने के लिए अधिक मेमोरी की आवश्यकता नहीं होती है सूचियों की प्रतिलिपि (जिसमें ओपी ने अपने प्रश्न का उल्लेख किया है)

— एडम स्नाइडर

Answer 10

एक प्रसिद्ध कार्य है जो इसे संभाल सकता है:

from sklearn.model_selection import train_test_split
X, _, Y, _ = train_test_split(X,Y, test_size=0.0)

बस test_size को 0 पर सेट करने से बंटवारे से बचा जा सकेगा और आपको डेटा में फेरबदल मिलेगा। हालांकि आमतौर पर ट्रेन को विभाजित करने और डेटा का परीक्षण करने के लिए इसका उपयोग किया जाता है, लेकिन यह उन्हें भी फेरबदल करता है।
से प्रलेखन

भाजित सरणियों या मैट्रिसेस को रैंडम ट्रेन और टेस्ट सबसेट में विभाजित करें

त्वरित उपयोगिता जो इनपुट सत्यापन और अगले (ShuffleSplit ()। स्प्लिट (एक्स, वाई)) और एक ऑनलाइनर में विभाजन (और वैकल्पिक रूप से सबमिशनिंग) डेटा के लिए एक कॉल में इनपुट डेटा के लिए आवेदन को लपेटता है।

Comments

मैं विश्वास नहीं कर सकता कि मैंने कभी ऐसा नहीं सोचा था। आपका जवाब शानदार है।

— लॉन्ग

Answer 11

कहें कि हमारे पास दो सरणियाँ हैं: ए और बी।

a = np.array([[1,2,3],[4,5,6],[7,8,9]])
b = np.array([[9,1,1],[6,6,6],[4,2,0]]) 

हम पहले आयाम को क्रमबद्ध करके पंक्ति सूचकांकों को प्राप्त कर सकते हैं

indices = np.random.permutation(a.shape[0])
[1 2 0]

फिर उन्नत अनुक्रमण का उपयोग करें। यहां हम एक ही सूचकांक का उपयोग कर रहे हैं ताकि दोनों सरणियों को एकजुट किया जा सके।

a_shuffled = a[indices[:,np.newaxis], np.arange(a.shape[1])]
b_shuffled = b[indices[:,np.newaxis], np.arange(b.shape[1])]

इसके बराबर है

np.take(a, indices, axis=0)
[[4 5 6]
 [7 8 9]
 [1 2 3]]

np.take(b, indices, axis=0)
[[6 6 6]
 [4 2 0]
 [9 1 1]]

Comments

सिर्फ एक [सूचकांक ,:] या बी [सूचकांक ,:] क्यों नहीं?

— केव

Answer 12

यदि आप सरणियों की प्रतिलिपि बनाने से बचना चाहते हैं, तो मैं सुझाव दूंगा कि आप क्रमपरिवर्तन सूची बनाने के बजाय, आप सरणी में प्रत्येक तत्व से गुजरते हैं, और इसे सरणी में किसी अन्य स्थिति में बेतरतीब ढंग से स्वैप करते हैं

for old_index in len(a):
    new_index = numpy.random.randint(old_index+1)
    a[old_index], a[new_index] = a[new_index], a[old_index]
    b[old_index], b[new_index] = b[new_index], b[old_index]

यह Knuth-Fisher-Yates फेरबदल एल्गोरिथ्म को लागू करता है।

Comments

codinghorror.com/blog/2007/12/the-danger-of-naivete.html ने मुझे अपने स्वयं के फेरबदल एल्गोरिदम को लागू करने से सावधान किया है; यह मेरे सवाल पूछने के लिए जिम्मेदार है। :) हालांकि, आपको यह बताने का बहुत अधिकार है कि मुझे नथ-फिशर-येट्स एल्गोरिथ्म का उपयोग करने पर विचार करना चाहिए।

— जोश ब्लीचर स्नाइडर

अच्छी तरह से देखा जाता है, मैंने अभी कोड तय किया है। वैसे भी, मुझे लगता है कि इन-प्लेस फेरबदल का मूल विचार मनमाने ढंग से संख्या में सरणियों के लिए स्केलेबल है जो प्रतियां बनाने से बचा जाता है।

— डेवप

कोड अभी भी गलत है (यह भी नहीं चलेगा)। इसे काम करने के लिए, इसके len(a)द्वारा प्रतिस्थापित करें reversed(range(1, len(a)))। लेकिन यह वैसे भी बहुत कुशल नहीं होगा।

— स्वेन मार्नाच

Answer 13

यह एक बहुत ही सरल समाधान की तरह लगता है:

import numpy as np
def shuffle_in_unison(a,b):

    assert len(a)==len(b)
    c = np.arange(len(a))
    np.random.shuffle(c)

    return a[c],b[c]

a =  np.asarray([[1, 1], [2, 2], [3, 3]])
b =  np.asarray([11, 22, 33])

shuffle_in_unison(a,b)
Out[94]: 
(array([[3, 3],
        [2, 2],
        [1, 1]]),
 array([33, 22, 11]))

Answer 14

एक उदाहरण के साथ, मैं यही कर रहा हूं:

combo = []
for i in range(60000):
    combo.append((images[i], labels[i]))

shuffle(combo)

im = []
lab = []
for c in combo:
    im.append(c[0])
    lab.append(c[1])
images = np.asarray(im)
labels = np.asarray(lab)

Comments

यह कम या ज्यादा के बराबर है combo = zip(images, labels); shuffle(combo); im, lab = zip(*combo), बस धीमा है। चूंकि आप वैसे भी Numpy का उपयोग कर रहे हैं, इसलिए Numpy combo = np.c_[images, labels], फेरबदल और unzip का उपयोग करके सरणियों को फिर से ज़िप करने के लिए एक बहुत तेज़ समाधान होगा images, labels = combo.T। कि मान लिया जाये labelsऔर imagesएक ही लंबाई के साथ शुरू करने के लिए की एक आयामी NumPy सरणी हैं, यह आसानी से सबसे तेजी से समाधान किया जाएगा। यदि वे बहुआयामी हैं, तो मेरा उत्तर ऊपर देखें।

— स्वेन मार्नाच

ठीक है कि समझ में आता है। धन्यवाद! @SvenMarnach

— ajfbiw.s

Answer 15

मैंने दूसरा आर्ग लेने के लिए अजगर का यादृच्छिक.शफल () बढ़ाया:

def shuffle_together(x, y):
    assert len(x) == len(y)

    for i in reversed(xrange(1, len(x))):
        # pick an element in x[:i+1] with which to exchange x[i]
        j = int(random.random() * (i+1))
        x[i], x[j] = x[j], x[i]
        y[i], y[j] = y[j], y[i]

इस तरह से मुझे यकीन हो सकता है कि फेरबदल इन-प्लेस होता है, और फ़ंक्शन बहुत लंबा या जटिल नहीं है।

Answer 16

बस उपयोग करें numpy...

पहले दो इनपुट सरणियों को मर्ज करें 1D सरणी लेबल (y) है और 2D सरणी डेटा (x) है और उन्हें NumPy shuffleविधि से फेरबदल करें । अंत में उन्हें विभाजित करें और वापस लौटें।

import numpy as np

def shuffle_2d(a, b):
    rows= a.shape[0]
    if b.shape != (rows,1):
        b = b.reshape((rows,1))
    S = np.hstack((b,a))
    np.random.shuffle(S)
    b, a  = S[:,0], S[:,1:]
    return a,b

features, samples = 2, 5
x, y = np.random.random((samples, features)), np.arange(samples)
x, y = shuffle_2d(train, test)