Np where là gì

5 hàm mảng numpy bị đánh giá thấp mà bạn nên biết.

Các chức năng khó hiểu với các ví dụ thời gian thực

Ảnh của Chris Liverani trên Unsplash

Vậy Numpy là gì? Numpy là viết tắt của Numerical Python. Nó là một gói tính toán khoa học bằng Python (từ trang web numpy). Thư viện Numpy giúp chúng ta tạo, thao tác, thao tác định hình, sắp xếp, lựa chọn và nhiều thứ khác trên mảng n chiều. Numpy là một thư viện rất mạnh và có tốc độ cực nhanh so với các danh sách của Python.

Tôi sẽ cố gắng giải thích về 5 thói quen (chức năng) numpy bị đánh giá thấp với một số ví dụ trong thế giới thực.

Các chức năng mà tôi sẽ đề cập trong sổ tay này là:

• np.reshape () - thao tác hình dạng
• np.where () - thao tác tìm kiếm
• np.stack () - thao tác hình dạng
• np.argmax () - thao tác tìm kiếm
• np.cumsum () - phép toán thống kê

Danh sách các chức năng được giải thích

• function1 = np.reshape () => để thay đổi hình dạng của mảng
• function2 = numpy.where () => cho các hoạt động giống như SQL
• function3 = numpy.stack () => để xếp chồng nhiều mảng => dùng trong xử lý ảnh thời gian thực
• function4 = numpy.argmax () => để tìm ra các chỉ số của giá trị lớn nhất trong một mảng
• function5 = numpy.cumsum () => để tính tổng số đang chạy => được sử dụng trong các ứng dụng tài chính và bán hàng

Hàm 1 - np.reshape

Tình huống 1: thu thập nhiệt độ phòng

Giả sử rằng chúng tôi đang thu thập nhiệt độ phòng trong nhà của chúng tôi mỗi ngày sáu giờ một lần (tức là 4 lần trong một ngày).

Bây giờ từ hình ảnh dưới đây cho phép nói rằng nhiệt độ thu được trong một ngày là: (C = c độ, F = fahrenheit)

• C, F, C, F, C, F, C, F

Để làm điều đó, chúng tôi sử dụng hàm reshape () (vị trí lẻ = c, vị trí chẵn = fahrenheit).

temperatures = [14, 57.2, 7, 44.6, 18, 66.4, 25, 77] new_temperatures = np.reshape(temperatures, newshape=(4,2)) new_temperatures Output: array([[14. , 57.2], [ 7. , 44.6], [18. , 66.4], [25. , 77.]])

Chúng tôi đã chuyển đổi mảng 1 chiều (danh sách) thành mảng 2 chiều bằng cách sử dụng newshape = (4,2) tức là 4 hàng và 2 cột.

print('Below are the temperatures recorded today:') for c,f in new_temperatures: print(f'Celsius: {c}, Fahrenheit: {f}') Output: Below are the temperatures recorded today: Celsius: 14.0, Fahrenheit: 57.2 Celsius: 7.0, Fahrenheit: 44.6 Celsius: 18.0, Fahrenheit: 66.4 Celsius: 25.0, Fahrenheit: 77.0

Giờ đây, người dùng cuối có thể trích xuất các phần tử của mảng theo cặp để thực hiện phân tích nhanh nhiệt độ được ghi lại.

Tình huống 2: thu thập thời gian vòng đua của các tay đua F1

Giả sử rằng chúng ta đang thu thập thời gian thực hiện của năm tay đua F1 để hoàn thành mỗi vòng đua (tính bằng phút).

Dữ liệu thu thập được ở định dạng danh sách danh sách.

lap_times = [ [3.1, 2.73, 2.64, 3.05, 2.99], [2.71, 2.99, 2.94, 2.94, 2.58], [3.01, 3.73, 2.74, 3.86, 3.62] ] all_lap_times = np.reshape(lap_times, newshape=-1) all_lap_times Output: array([3.1 , 2.73, 2.64, 3.05, 2.99, 2.71, 2.99, 2.94, 2.94, 2.58, 3.01, 3.73, 2.74, 3.86, 3.62]) all_lap_times.shape Output: (15,)

Nếu bạn có một số kinh nghiệm về SQL, thì Numpy's where tương tự như mệnh đề WHERE trong SQL. Ngoại trừ nó hoạt động hơi khác một chút.

Numpy's nơi hoạt động như thế này:

• np.where (điều kiện, nếu có thì đưa ra đầu ra này, nếu không thì đưa ra đầu ra này)

Ví dụ: np.where (x> 10, A, B) => ở đây nếu x lớn hơn 10 thì A được trả về là đầu ra của chúng ta, nếu sai B được trả về là đầu ra của chúng ta.

Các ví dụ dưới đây mà tôi đề cập là về phân tích cricket.

Tôi là một fan hâm mộ lớn của môn thể thao này, Cricket . Tôi sẽ lấy một tập dữ liệu ví dụ chứa số lần chạy do Sachin Tendulkar và Rahul Dravid ghi được trong một trận đấu mà Ấn Độ đã thi đấu.

Lưu ý: Tôi không sở hữu tập dữ liệu này. Tôi đã tải xuống tài nguyên này từ liên kết này:https://drive.google.com/file/d/1lBEeQ9iycLmQX9LkA8gq2Tm1Utd9sKu8/view?usp=sharing

Tập dữ liệu trông giống như sau:

Tệp .tsv tương tự như tệp CSV nhưng được phân tách bằng TAB thay vì COMMA (,), đó là lý do tại sao phần mở rộng tệp là .tsv

Ý nghĩa của các cột:

• Sachin = số lần chạy do Sachin ghi được
• Dravid = số lần chạy được Dravid ghi
• Ấn Độ = tổng số lần chạy mà Ấn Độ đã thực hiện trong trận đấu đó

# Before we perform our numpy operations let us load our dataset in a numpy array import numpy data = np.loadtxt("https://drive.google.com/file/d/1lBEeQ9iycLmQX9LkA8gq2Tm1Utd9sKu8/view?usp=sharing", skiprows=1) data.shape Output: (225, 4) # Example 1 - find number of centuries made by Sachin and Dravid # Sachin - column 1 (0, 1, 2) sachin_centuries = np.where(data[:, 1] >= 100) # Dravid - column 2 (0, 1, 2) dravid_centuries = np.where(data[:, 2] >= 100) print(sachin_centuries) # output returned is the index of elements where sachin's score was >= 100 print(dravid_centuries) # output returned is the index of elements where dravid's score was >= 100 Output: (array([ 0, 4, 22, 30, 37, 44, 47, 56, 57, 64, 68, 94, 115, 116, 134, 148, 159, 166, 175, 177, 181, 182, 204, 208, 210, 221], dtype=int64),) (array([ 5, 11, 21, 37, 60, 88, 205, 208], dtype=int64),)

• Lưu ý rằng các kết quả đầu ra ở trên trả về một Tuple với danh sách các chỉ mục trong đó số lần chạy là 100 hoặc hơn (tức là một thế kỷ)
• Để truy cập vào mảng, chúng tôi sử dụng đầu ra [0] vì chỉ có một mảng bên trong Tuple

sachin_centuries[0] Output: array([ 0, 4, 22, 30, 37, 44, 47, 56, 57, 64, 68, 94, 115, 116, 134, 148, 159, 166, 175, 177, 181, 182, 204, 208, 210, 221], dtype=int64) Để tìm tổng số thế kỷ, chúng tôi sử dụngprint(f'Total centuries by Sachin: {sachin_centuries[0].shape[0]} out of {data.shape[0]} matches.') print(f'Total centuries by Dravid: {dravid_centuries[0].shape[0]} out of {data.shape[0]} matches.') Output: Total centuries by Sachin: 26 out of 225 matches. Total centuries by Dravid: 8 out of 225 matches. # Example 2 - find out if both sachin and dravid made centuries in a single match both_centuries = np.where((data[:,1] >= 100) & (data[:,2] >= 100)) print(both_centuries) # returns indices where the condition met print('\n') for i in both_centuries[0]: print(f'Sachin scored: {data[i][1]}, Dravid scored {data[i][2]} and India\'s total is {data[i][3]}') print('\n') print('Or may be print if both have scored fifty runs in a single match:') print('-'*70) fifties = np.where( ((data[:,1] >= 50) & (data[:,1] < 100)) & ((data[:,2] >= 50) & (data[:,2] < 100))) print(fifties)

Or may be print if both have scored fifty runs in a single match: ---------------------------------------------------------------------- (array([ 7, 72, 84, 143, 163, 164, 195, 200], dtype=int64),)

for i in fifties[0]: print(f'Sachin scored: {data[i][1]}, Dravid scored {data[i][2]} and India\'s total is {data[i][3]}') Output: Sachin scored: 86.0, Dravid scored 74.0 and India's total is 288.0 Sachin scored: 99.0, Dravid scored 74.0 and India's total is 229.0 Sachin scored: 50.0, Dravid scored 62.0 and India's total is 256.0 Sachin scored: 93.0, Dravid scored 79.0 and India's total is 279.0 Sachin scored: 60.0, Dravid scored 57.0 and India's total is 309.0 Sachin scored: 68.0, Dravid scored 59.0 and India's total is 202.0 Sachin scored: 62.0, Dravid scored 56.0 and India's total is 276.0 Sachin scored: 99.0, Dravid scored 92.0 and India's total is 304.0

Trong ví dụ trên, hãy quan sát rằng tôi đã kết hợp nhiều điều kiện trong hàm where ().

Logic được thực hiện theo các bước bên dưới:

• tìm các điểm dữ liệu mà sachin ghi được> 50 và <100
• nếu điều đó là đúng, sau đó tìm dravid ghi được> 50 và <100
• nếu cả hai câu lệnh trên đều đúng, thì lấy chỉ số của hàng đó

Hàm 3 - np.stack ()

Hàm ngăn xếp của Numpy được sử dụng để kết hợp nhiều mảng và nhận được một mảng đầu ra.

Bây giờ điều này có thể tương tự như nối, ngoại trừ ngăn xếp có thể hữu ích với các hoạt động tham số trục. Hãy để chúng tôi xem nó hoạt động như thế nào và khác với np.concatenate ()

Ví dụ 1 - đang làm việc (ví dụ cơ bản)

arr1 = [1,4,5] arr2 = [2,9,6] # default stacking is by horizontal axis output = np.stack((arr1, arr2)) print(output) print('\n') print(f'Output array dimension: {output.ndim}') print('\n') Output: [[1 4 5] [2 9 6]] Output array dimension: 2

Ngăn xếp của Numpy là một hàm thao tác trên mảng. Tài liệu nói rằng nó tham gia một chuỗi các mảng dọc theo một trục mới.

Trong ví dụ trên, một phép nối đơn giản được thực hiện dọc theo trục hoành, tức là arr1 được xếp chồng lên trên arr2.

Ví dụ 2 - (sử dụng tham số trục)

Nối các mảng nhiều chiều và sử dụng tham số trục.

arr1 = np.array([ [1,4,5], [7,3,2] ]) print(f'arr1 dimension: {arr1.ndim}') arr2 = np.array([ [2,9,6], [0,5,7] ]) print(f'arr2 dimension: {arr2.ndim}') print('\n') output = np.stack((arr1, arr2), axis=0) print(f'Stacked output array looks like: \n{output}') print('\n') print(f'Dimension of output array is: {output.ndim}') arr1 dimension: 2 arr2 dimension: 2 Stacked output array looks like: [[[1 4 5] [7 3 2]] [[2 9 6] [0 5 7]]] Dimension of output array is: 3

Hàm argmax của Numpy trả về các chỉ số của các giá trị lớn nhất dọc theo trục.

Tôi sẽ cố gắng chứng minh việc sử dụng argmax bằng cách sử dụng tập dữ liệu cricket mà tôi đã sử dụng trong fuction thứ hai (np.where ()) và đó là các ví dụ.

Giả sử chúng tôi muốn tìm vị trí số lần chạy tối đa của Sachin hoặc Dravid.

import numpy data = np.loadtxt("https://drive.google.com/file/d/1lBEeQ9iycLmQX9LkA8gq2Tm1Utd9sKu8/view?usp=sharing", skiprows=1) print(f'Printing first 5 rows of the dataset: \n {data[:4,:]}') print('\n') print(f'Dimension of data: {data.ndim}') print('\n') max_position = np.argmax(data[:, 1], axis=0) # column 1 is sachin's scores print(f'Max position: {max_position}') print(f'Max position row: {data[max_position]} and Sachin scored: {data[max_position, 1]} runs.')

Printing first 5 rows of the dataset: [[ 0. 100. 78. 342.] [ 1. 11. 62. 191.] [ 2. 8. 85. 252.] [ 3. 71. 24. 307.]] Dimension of data: 2 Max position: 37 Max position row: [ 37. 186. 153. 345.] and Sachin scored: 186.0 runs.

Giải thích ví dụ trên

Trong ví dụ trên, tôi đã trích xuất chỉ mục của hàng mà Sachin ghi được điểm tối đa trong tất cả các trận đấu trong tập dữ liệu của chúng tôi.

Tương tự cho Dravid:

max_position = np.argmax(data[:, 2], axis=0) # column 2 is dravid's scores print(f'Max position: {max_position}') print(f'Max position row: {data[max_position]} and Dravid scored: {data[max_position, 2]} runs.') max_position = np.argmax(data[:, 3], axis=0) # column 3 is India's scores print(f'Max position: {max_position}') print(f'Max position row: {data[max_position]} and India scored: {data[max_position, 3]} runs.')

Một phát hiện thú vị là điểm của cả Sachin và Dravid đều cao nhất trong một trận đấu duy nhất mà Ấn Độ thi đấu.

Hàm 5 - np.cumsum () - tổng tích lũy

Hàm cumsum () của Numpy tính tổng tích lũy của các giá trị trong mảng và tạo ra một mảng đầu ra mới.

Sự khác biệt giữa sum () và cumsum () như sau:

• giả sử bạn có một mảng [1,4,3,5,7,9] thì hàm sum () cho kết quả là 1 + 4 + 3 + 5 + 7 + 9 = 29
• nhưng một hàm cumsum () tính toán cùng một mảng khác nhau và đưa ra kết quả => [1, 5, 8, 13, 20, 29]

Cả sum () và cumsum () đều cho tổng cuối cùng của các phần tử mảng, nhưng cumsum () sẽ thực hiện "tổng số đang chạy" của mảng.

Ví dụ, giả sử rằng bạn đang đếm số tiền tiết kiệm bạn đã làm hàng tuần trong khoảng một tháng.

• tuần đầu tiên bạn tiết kiệm được 100 rupee, tuần thứ hai 150 rupee, tuần thứ ba 150 rupee, tuần thứ tư 200 rupee
• cumsum () cho biết tổng số đang chạy
• tức là đầu tiên = 100
• thứ hai = thứ nhất + 150 = 100 + 150 = 250
• thứ ba = thứ hai + 150 = 250 + 150 = 400
• thứ tư = thứ ba + 200 = 400 + 200 = 600

Giả sử chúng ta đã tiết kiệm tiền được 8 tuần và tổng số tiền cumsum () hoặc đang chạy sẽ là

savings = np.array([100, 150, 150, 200, 125, 100, 75, 130]) np.cumsum(savings) Output: array([ 100, 250, 400, 600, 725, 825, 900, 1030], dtype=int32)

Lưu ý đầu ra ở trên, hàm cumsum () được tính toán tổng số đang chạy như thế này:

• 100
• 250 (100 + 150)
• 400 (100 + 150 + 250)
• 600 (100 + 150 + 250 + 200)
• 725 (100 + 150 + 250 + 200 + 125)
• 825 (100 + 150 + 250 + 200 + 125 + 100)
• 900 (100 + 150 + 250 + 200 + 125 + 100 + 75)
• 1030 (100 + 150 + 250 + 200 + 125 + 100 + 75 + 130)

Ví dụ 2 - cumsum () với mảng 2 chiều

arr = np.array([ [1,5,3], [6,4,9] ]) np.cumsum(arr) Output: array([ 1, 6, 9, 15, 19, 28], dtype=int32)

Lưu ý rằng ngay cả với một hàm cumsum () mảng 2-D đã cung cấp một mảng đầu ra 1-D.

Hiện tại nó đang thực hiện một hoạt động rowwise tức là 1 + 5 + 3 + 6 + 4 + 9 => 1, 6, 9, 15, 19, 28

Ví dụ 2 - tiếp tục - thực hiện cumsum () sử dụng tham số trục

arr = np.array([ [1,5,3], [6,4,9] ]) np.cumsum(arr, axis=1) Output: array([[ 1, 6, 9], [ 6, 10, 19]], dtype=int32)

tức là đầu tiên nó tính tổng tích lũy của [1,5,3] => [1, 6 (1 + 5), 9 (6 + 3)], sau đó là [6, 4, 9] tiếp theo => [6, 10 (6 + 4), 19 (10 + 9)]

Một số nhận xét cuối cùng về thời điểm sử dụng chức năng này:

Hàm cumsum () của Numpy là một hàm hữu ích cho các tập dữ liệu liên quan đến tài chính. Ví dụ: trong kịch bản thực tế, bạn có thể tìm thấy tổng doanh thu tích lũy mà một công ty cụ thể đã thực hiện trong một năm hoặc tìm ra tổng số người đăng ký Netflix tích lũy trong một năm và nhiều ví dụ ứng dụng khác.

Phần kết luận

Chúng ta đã đề cập đến cách thực hiện thao tác với mảng (hình dạng), tìm kiếm các phần tử của mảng bằng cách sử dụng hàm where () và thậm chí một số trường hợp sử dụng thống kê.

Numpy là một công cụ rất mạnh mẽ và hữu ích được nhiều người trên thế giới sử dụng. Nếu bạn theo dõi một số nghiên cứu điển hình thực tế về Numpy, bạn sẽ ngạc nhiên khi biết thư viện mạnh mẽ như thế nào. Một sự thật thú vị là Numpy đã được sử dụng trong việc chụp ảnh máy tính của bức ảnh thực tế đầu tiên về một lỗ đen (chết tiệt !!!!!!!!!). Điều đó thật tuyệt vời.

Liên kết tham khảo

Cung cấp liên kết đến tài liệu tham khảo của bạn và các bài viết thú vị khác về mảng Numpy:

• Hướng dẫn chính thức của Numpy: https://numpy.org/doc/stable/user/quickstart.html
• https://stackoverflow.com/questions/50656307/numpy-typeerror-ufunc-bitwise-and-not-supported-for-the-input-types-when-us
• http://www.degeneratestate.org/posts/2016/Oct/23/image-processing-with-numpy/
• Nghiên cứu điển hình: đi tới https://numpy.org/ và cuộn xuống phần NGHIÊN CỨU TRƯỜNG HỢP.