পাইথন কম ভার্বোসে কীভাবে একটি 2-মাত্রিক নিম্পিক অ্যারে সাধারণ করতে?

Question 1

একটি 3 বার 3 টি নমপি অ্যারে দেওয়া হয়েছে

a = numpy.arange(0,27,3).reshape(3,3)

# array([[ 0,  3,  6],
#        [ 9, 12, 15],
#        [18, 21, 24]])

2-মাত্রিক অ্যারের সারিগুলি স্বাভাবিক করার জন্য আমি ভেবেছিলাম

row_sums = a.sum(axis=1) # array([ 9, 36, 63])
new_matrix = numpy.zeros((3,3))
for i, (row, row_sum) in enumerate(zip(a, row_sums)):
    new_matrix[i,:] = row / row_sum

আরও ভাল উপায় থাকতে হবে, আছে না?

সম্ভবত পরিষ্কার করতে: আমার সাধারণকরণের অর্থ, প্রতি সারিতে প্রবেশের যোগফল অবশ্যই একটি হতে হবে। তবে আমি মনে করি এটি বেশিরভাগ মানুষের কাছে স্পষ্ট হবে।

Question 2

এর জন্য সম্প্রচারটি সত্যই ভাল:

row_sums = a.sum(axis=1)
new_matrix = a / row_sums[:, numpy.newaxis]

row_sums[:, numpy.newaxis]হওয়া থেকে row_sums reshapes (3,)হচ্ছে (3, 1)। আপনি যখন তা করবেন a / b, aএবং bএকে অপরের বিরুদ্ধে সম্প্রচার করা হয়।

আপনি এখানে বা আরও ভাল এখানে সম্প্রচার সম্পর্কে আরও শিখতে পারেন ।

Question 3

সাইকিট-লার একটি ফাংশন normalize()দেয় যা আপনাকে বিভিন্ন নরমালাইজেশন প্রয়োগ করতে দেয়। "এটির যোগফল 1 করে" তাকে এল 1-আদর্শ বলে। অতএব:

from sklearn.preprocessing import normalize

matrix = numpy.arange(0,27,3).reshape(3,3).astype(numpy.float64)
# array([[  0.,   3.,   6.],
#        [  9.,  12.,  15.],
#        [ 18.,  21.,  24.]])

normed_matrix = normalize(matrix, axis=1, norm='l1')
# [[ 0.          0.33333333  0.66666667]
#  [ 0.25        0.33333333  0.41666667]
#  [ 0.28571429  0.33333333  0.38095238]]

এখন আপনার সারিগুলি 1 এর সমষ্টি হবে।

Question 4

আমি এই কাজ করা উচিত,

a = numpy.arange(0,27.,3).reshape(3,3)

a /=  a.sum(axis=1)[:,numpy.newaxis]

Question 5

আপনি যদি প্রতিটি সারিটি স্বাভাবিক করার চেষ্টা করছেন তবে এর দৈর্ঘ্য এক হ'ল (অর্থাত্ একটি সারির এককের দৈর্ঘ্য এক বা এক সারিতে প্রতিটি উপাদানটির বর্গের যোগফল এক):

import numpy as np

a = np.arange(0,27,3).reshape(3,3)

result = a / np.linalg.norm(a, axis=-1)[:, np.newaxis]
# array([[ 0.        ,  0.4472136 ,  0.89442719],
#        [ 0.42426407,  0.56568542,  0.70710678],
#        [ 0.49153915,  0.57346234,  0.65538554]])

যাচাই করা হচ্ছে:

np.sum( result**2, axis=-1 )
# array([ 1.,  1.,  1.])

Question 6

আমার মনে হয় আপনি এই দ্বারা 1 সারি উপাদানের সমষ্টি স্বাভাবিক করতে পারেন: new_matrix = a / a.sum(axis=1, keepdims=1)। এবং কলামটি নরমালাইজেশন দিয়ে করা যেতে পারে new_matrix = a / a.sum(axis=0, keepdims=1)। আশা করি এটি উত্তোলন করতে পারে

Question 7

আপনি বিল্ট-ইন নিমপি ফাংশনটি ব্যবহার করতে পারেন: np.linalg.norm(a, axis = 1, keepdims = True)

Question 8

এটি প্রদর্শিত হয় যে প্রদর্শিত হয়

def normalizeRows(M):
    row_sums = M.sum(axis=1)
    return M / row_sums

Question 9

আপনি ম্যাট্রিক্স স্থানান্তরও ব্যবহার করতে পারেন:

(a.T / row_sums).T

Question 10

বা ল্যাম্বদা ফাংশন ব্যবহার করে, পছন্দ করুন

>>> vec = np.arange(0,27,3).reshape(3,3)
>>> import numpy as np
>>> norm_vec = map(lambda row: row/np.linalg.norm(row), vec)

ভেক্টরের প্রতিটি ভেক্টরের একটি ইউনিট আদর্শ থাকবে।

Question 11

এখানে আরও একটি সম্ভাব্য উপায় ব্যবহার করা হয়েছে reshape:

a_norm = (a/a.sum(axis=1).reshape(-1,1)).round(3)
print(a_norm)

বা Noneকাজগুলি ব্যবহার করে:

a_norm = (a/a.sum(axis=1)[:,None]).round(3)
print(a_norm)

আউটপুট :

array([[0.   , 0.333, 0.667],
       [0.25 , 0.333, 0.417],
       [0.286, 0.333, 0.381]])

Question 12

normed_matrix = normalize(input_data, axis=1, norm='l1')
print(normed_matrix)

যেখানে ইনপুট_ডেটা হল আপনার 2 ডি অ্যারের নাম