একযোগে দুটি আকাঙ্ক্ষিত অ্যারে পরিবর্তন করার আরও ভাল উপায়

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]))

যাইহোক, এটি ক্লানকি, অদক্ষ এবং ধীরে ধীরে অনুভূত হয় এবং এর অ্যারেগুলির একটি অনুলিপি তৈরি করা দরকার - আমি বরং এগুলি স্থানটিতে স্থানান্তরিত করব, কারণ তারা বেশ বড় হবে be

এই সম্পর্কে আরও ভাল উপায় আছে? দ্রুত সম্পাদন এবং কম স্মৃতি ব্যবহার আমার প্রাথমিক লক্ষ্য, তবে মার্জিত কোডটিও খুব সুন্দর।

অন্য একজন ভেবেছিল আমার এই ছিল:

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

ছয় বছর পরে, আমি এই প্রশ্নটি কতটা জনপ্রিয় বলে প্রমাণিত হয়ে বিস্মিত ও অবাক হয়েছি। এবং খানিকটা আনন্দদায়ক কাকতালীয় সময়ে, গো ১.১০ এর জন্য আমি গণিত / র্যান্ড অবদান রেখেছি standard স্ট্যান্ডার্ড লাইব্রেরিতে সাফ করুন । এপিআই এর ডিজাইনটি একসাথে দুটি অ্যারে স্থানান্তরিত করতে তুচ্ছ করে তোলে এবং এটি করা এমনকি ডক্সে উদাহরণ হিসাবে অন্তর্ভুক্ত।

— জোশ ব্লিচার স্নাইডার

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

পুনরায়: ভীতিকর সমাধান: আমি কেবল উদ্বেগ নিয়েছি যে বিভিন্ন আকারের অ্যারেগুলি (কল্পিতভাবে) আরএনজে বিভিন্ন সংখ্যক কল আনতে পারে, যা ডাইভার্জেন্সের কারণ হতে পারে। তবে, আমি মনে করি আপনি ঠিক বলেছেন যে বর্তমান আচরণ সম্ভবত পরিবর্তিত হওয়ার সম্ভাবনা নেই, এবং একটি খুব সাধারণ ডক্টেস্ট সঠিক আচরণের নিশ্চয়তা দেয় খুব সহজ ...

— জোশ ব্লিচার স্নাইডার

আমি আপনার প্রস্তাবিত পদ্ধতির পছন্দ করি এবং অবশ্যই একটি এবং বি জীবনকে ইউনিফাইড সি অ্যারে হিসাবে শুরু করার ব্যবস্থা করতে পারি। যাইহোক, এ এবং বি শিফট করার খুব শীঘ্রই (জিপিইউতে দক্ষ হস্তান্তর করার জন্য) সামঞ্জস্যপূর্ণ হওয়া দরকার, তাই আমার মনে হয় যে, আমার বিশেষ ক্ষেত্রে আমি যেভাবেই হোক না কেন একটি এবং বি এর অনুলিপিগুলি শেষ করব। :(

— জোশ ব্লিচার স্নাইডার

@ জোশ: নোট যা numpy.random.shuffle()পাইথন তালিকাগুলি বা নম্পপি অ্যারেগুলির মতো স্বেচ্ছাসেবী পরিবর্তনযোগ্য ক্রমগুলিতে পরিচালনা করে। অ্যারের আকারটি কেবল ক্রমের দৈর্ঘ্য নয়, তাতে কিছু আসে যায় না। এটি আমার মতে পরিবর্তন হওয়ার খুব সম্ভাবনা নেই is

— সোভেন মারনাচ

আমি এটা জানতাম না। এটি আমাকে এতে অনেক বেশি স্বাচ্ছন্দ্য বোধ করে। ধন্যবাদ.

— জোশ ব্লিচার স্নাইডার

@ স্পেনমার্নাচ: আমি নীচে একটি উত্তর পোস্ট করেছি। আপনি কি মনে করেন যে এটি বোধ হয় / এটি করার একটি ভাল উপায়?

— 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

এই করে , কপি তৈরি যেমন উন্নত ইন্ডেক্স ব্যবহার করে। তবে অবশ্যই এটি আসলটির চেয়ে দ্রুত।

— সোভেন মারনাচ

@ এমটিআরডব্লিউ: আসল অ্যারেগুলি ছোঁয়াচে থাকা একমাত্র সত্যটি প্রত্যাখ্যান করে না যে ফিরে আসা অ্যারেগুলি একই ডেটার মতামত। তবে এগুলি প্রকৃতপক্ষে নয়, যেহেতু 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 সেকেন্ড এবং আমার জন্য 27 মিলিয়ন সেকেন্ডের জন্য প্রতিটি মিলিয়ন কল পেয়েছি।

— mtrw

আমি এর সরলতা এবং পঠনযোগ্যতা সত্যিই পছন্দ করি এবং অগ্রণী সূচকগুলি আমাকে অবাক করে ও অবাক করে দেয়; তার জন্য এই উত্তরটি সহজেই +1 পায়। আশ্চর্যের সাথে যথেষ্ট, যদিও আমার (বৃহত) ডেটাসেটগুলিতে এটি আমার মূল ফাংশনের চেয়ে ধীর: আমার আসলটি 10 ​​টি পুনরাবৃত্তির জন্য 1.8 ডলার নেয় এবং এটি ~ 2.7s নেয় s উভয় সংখ্যা বেশ সামঞ্জস্যপূর্ণ। আমি যে ডেটাসেটটি পরীক্ষার জন্য ব্যবহার করেছি তা a.shapeহ'ল (31925, 405)এবং b.shapeহ'ল (31925,)।

— জোশ ব্লিচার স্নাইডার

হতে পারে, স্লোনেসের বিষয়টি আপনাকে এই জায়গায় করতে হবে না যে আপনি জায়গাটিতে জিনিসগুলি করছেন না, বরং পরিবর্তে নতুন অ্যারে তৈরি করছেন are অথবা সিপিথন অ্যারে-ইনডেক্সকে কীভাবে পার্স করে তা সম্পর্কিত কিছুটা অলসতার সাথে।

— orহোর এম

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]

দুটি অ্যারে এক্স, ওয়াই এখন দুজনেই এলোমেলোভাবে একই ভাবে বদলে গেছে

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

এটা সঠিক উত্তর. যখন আপনি এলোমেলো রাষ্ট্রের বস্তুগুলির কাছাকাছি যেতে পারেন তখন বিশ্বব্যাপী এনপি.র্যান্ডম ব্যবহার করার কোনও কারণ নেই।

— ইরোটমিক

একটি 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

সংযুক্ত তালিকাগুলির জন্য স্থানটিতে স্থানচ্যূত করার একটি উপায় হ'ল বীজ ব্যবহার করা (এটি এলোমেলো হতে পারে) এবং নফ্পি.আরন্ডম.শ্যাফল ব্যবহার করে বদল করা।

# 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)

এটাই. এটি ঠিক একইভাবে a এবং b উভয়কেই বদলাবে। এটি স্থানে করা হয় যা সর্বদা একটি প্লাস।

সম্পাদনা করুন, 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একসাথে পরিবর্তিত হয় না।

— ব্রুনো ক্লেইন

@ ব্রুনো ক্লেইন আপনি ঠিক বলেছেন আমি পোস্টটি এলোমেলো অবস্থায় পুনরায় বীজ করার জন্য স্থির করেছি। উভয় তালিকাগুলি একই সাথে বদল হওয়া সত্ত্বেও এটি একত্রিত না হলেও, তারা উভয়কে একই উপায়ে বদলে দেওয়া হয়েছে এই অর্থে একত্রিত হয়, এবং এটির জন্য আরও মেমরির প্রয়োজন হয় না তালিকাগুলির অনুলিপি (যা ওপি তাঁর প্রশ্নের মধ্যে উল্লেখ করেছেন)

— অ্যাডাম স্নাইডার

Answer 10

এটি পরিচালনা করতে পারে এমন একটি সুপরিচিত ফাংশন রয়েছে:

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

কেবলমাত্র টেস্ট_সাইজ 0 তে সেট করা বিভক্ত হওয়া এড়াতে এবং আপনাকে বদলানো ডেটা দেবে। যদিও এটি সাধারণত ট্রেন এবং ডেটা পরীক্ষার জন্য ব্যবহৃত হয়, এটি তাদের খুব বদলে দেয়। ডকুমেন্টেশন
থেকে

অ্যারে বা ম্যাট্রিকগুলিকে এলোমেলো ট্রেন এবং পরীক্ষার উপগ্রহে বিভক্ত করুন

দ্রুত ইউটিলিটি যা ইনপুট বৈধতা এবং পরবর্তী (শুফ্লস্প্লিট ()। বিভক্ত (এক্স, ওয়াই) এবং একটি অনিলনেয়ারে ডেটা বিভক্তকরণ (এবং optionচ্ছিকভাবে সাব্পাম্পলিং) ডেটার জন্য একক কলটিতে ডেটা ইনপুট করার জন্য অ্যাপ্লিকেশন ps

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]

এটি নথ-ফিশার-ইয়েটস শাফল আলগোরিদিম প্রয়োগ করে।

Comments

codinghorror.com/blog/2007/12/the-danger-of-naivete.html আমাকে নিজের শ্যাফল আলগোরিদিম বাস্তবায়নে সতর্ক করে তুলেছে; আমার এই প্রশ্নটি জিজ্ঞাসা করার জন্য এটি কিছুটা দায়বদ্ধ। :) তবে, আপনি খুব সঠিকভাবে উল্লেখ করেছেন যে আমার কাছে নুথ-ফিশার-ইয়েটস অ্যালগরিদম ব্যবহার করা উচিত।

— জোশ ব্লিচার স্নাইডার

ভাল স্পট, আমি এখন কোড ঠিক করেছি। যাইহোক, আমি মনে করি স্থানটিতে স্থানান্তরিত করার প্রাথমিক ধারণাটি স্বেচ্ছাসেবী সংখ্যক অ্যারেগুলিকে অনুলিপি তৈরি করা এড়ানো যায় is

— ডেভপ

কোডটি এখনও ভুল (এটি এমনকি চলবে না)। এটা কার্যকর করতে, প্রতিস্থাপন 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), কেবল ধীর। যেহেতু আপনি নম্পিকে যেভাবেই ব্যবহার করছেন combo = np.c_[images, labels], তাই নিম্পি , বদলানো এবং আবার আনজিপ ব্যবহার করে অ্যারেগুলিকে জিপ করা একটি আরও দ্রুত সমাধান images, labels = combo.T। যে ধরে নেওয়া যাক labelsএবং imagesএকই দৈর্ঘ্য দিয়ে শুরু করতে এক-মাত্রিক Numpy অ্যারে, এই সহজে দ্রুততম সমাধান হবে। এগুলি যদি বহুমাত্রিক হয় তবে উপরে আমার উত্তরটি দেখুন।

— সোভেন মারনাচ

ঠিক আছে যে বোধগম্য। ধন্যবাদ! @ স্পেনমার্নাচ

— আজফবিউইউ.এসব

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...

প্রথমে দুটি ইনপুট অ্যারে 1 ডি অ্যারে লেবেল (y) এবং 2 ডি অ্যারেটি ডেটা (এক্স) এবং মার্চ shuffleপদ্ধতিতে এগুলি মার্ফ করুন merge শেষ পর্যন্ত তাদের বিভক্ত এবং ফিরে।

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)