Creating sparse matrices in SciPy - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to import the sparse matrix module from scipy.

SciPy

from scipy import [1]

Drag options to blanks, or click blank then click option'

Astats

Barray

Csparse

Doptimize

Attempts:

3 left

💡 Hint

Common Mistakes

Importing unrelated modules like scipy.array or scipy.stats.

Forgetting to import the sparse module before using it.

The sparse module in scipy is used to create and work with sparse matrices efficiently.

2fill in blank

medium

Complete the code to create a 3x3 sparse matrix with data [1, 2, 3] at positions (0,0), (1,1), and (2,2) using the COO format.

SciPy

from scipy.sparse import coo_matrix

row = [0, 1, 2]
col = [0, 1, 2]
data = [1, 2, 3]
sparse_matrix = coo_matrix(([1], (row, col)), shape=(3, 3))

Drag options to blanks, or click blank then click option'

Adata

Brow

Ccol

D[1, 2, 3]

Attempts:

3 left

💡 Hint

Common Mistakes

Passing row or col instead of data as the first argument.

Passing a list literal instead of the variable holding data.

The first argument to coo_matrix is the data array containing the values to place in the sparse matrix.

3fill in blank

hard

Fix the error in the code to create a CSR sparse matrix from dense data.

SciPy

import numpy as np
from scipy.sparse import csr_matrix

dense = np.array([[0, 0, 1], [1, 0, 0], [0, 2, 0]])
sparse = csr_matrix([1])

Drag options to blanks, or click blank then click option'

Adense.tolist()

Bdense.shape

Cdense.flatten()

Ddense

Attempts:

3 left

💡 Hint

Common Mistakes

Passing a list instead of a numpy array causes errors.

Passing the shape instead of the data.

The csr_matrix constructor accepts a dense numpy array directly to convert it into a sparse matrix.

4fill in blank

hard

Fill both blanks to create a dictionary comprehension that maps each word to its length only if the length is greater than 3.

SciPy

words = ['data', 'science', 'is', 'fun']
lengths = {word: [1] for word in words if [2]

Drag options to blanks, or click blank then click option'

Alen(word)

Blen(word) > 3

Clen(word) < 3

Dword

Attempts:

3 left

💡 Hint

Common Mistakes

Using the word itself as the value instead of its length.

Using the wrong condition like less than 3.

The dictionary comprehension maps each word to its length using len(word). The condition filters words with length greater than 3 using len(word) > 3.

5fill in blank

hard

Fill all three blanks to create a dictionary comprehension that maps uppercase words to their counts only if the count is greater than 1.

SciPy

word_counts = {'data': 2, 'science': 1, 'fun': 3}
result = [1]: [2] for [3], [2] in word_counts.items() if [2] > 1}

Drag options to blanks, or click blank then click option'

Aword.upper()

Bcount

Cword

Ditem

Attempts:

3 left

💡 Hint

Common Mistakes

Using the wrong loop variable like 'item' instead of 'word'.

Not converting words to uppercase.

Using the wrong variable in the condition.

The comprehension maps the uppercase version of each word (word.upper()) to its count (count). The loop variable is word and count from word_counts.items(). The condition filters counts greater than 1.

Practice

1. What is the main advantage of using sparse matrices in data science?

easy

A. They make data sorting faster

B. They save memory by storing only non-zero values

C. They convert data into images

D. They increase the size of the data

Solution

1. Step 1: Understand sparse matrix storage

   Sparse matrices store only the non-zero elements instead of all elements.

2. Step 2: Identify the benefit

   By storing only non-zero values, sparse matrices save memory space significantly.

3. Final Answer:

   They save memory by storing only non-zero values -> Option B

4. Quick Check:

   Sparse matrices = memory saving [OK]

Hint: Sparse matrices store only non-zero values to save memory [OK]

Common Mistakes:

• Thinking sparse matrices store all values
• Confusing sparse matrices with data sorting
• Assuming sparse matrices increase data size

2. Which of the following is the correct way to create a COO sparse matrix using scipy?

easy

A. scipy.sparse.coo_matrix((data, (row, col)))

B. scipy.sparse.csr_matrix(data, row, col)

C. scipy.sparse.csc_matrix(data, row, col)

D. scipy.sparse.dense_matrix((data, (row, col)))

Solution

1. Step 1: Recall COO matrix creation syntax

   COO format uses tuple (data, (row, col)) inside coo_matrix constructor.

2. Step 2: Check options

   Only scipy.sparse.coo_matrix((data, (row, col))) matches the correct syntax for COO matrix creation.

3. Final Answer:

   scipy.sparse.coo_matrix((data, (row, col))) -> Option A

4. Quick Check:

   COO matrix = coo_matrix((data, (row, col))) [OK]

Hint: COO matrix needs (data, (row, col)) tuple [OK]

Common Mistakes:

• Using csr_matrix or csc_matrix syntax for COO
• Passing row and col as separate arguments
• Using non-existent dense_matrix function

3. What will be the output of this code?

import numpy as np
from scipy.sparse import coo_matrix
row = np.array([0, 1, 2])
col = np.array([1, 2, 0])
data = np.array([4, 5, 6])
sparse_mat = coo_matrix((data, (row, col)), shape=(3, 3))
print(sparse_mat.toarray())

medium

A. [[0 4 0]
[0 0 5]
[6 0 0]]

B. [[4 0 0]
[0 5 0]
[0 0 6]]

C. [[0 0 6]
[4 0 0]
[0 5 0]]

D. [[0 6 0]
[5 0 0]
[0 0 4]]

Solution

1. Step 1: Map data to positions

   Data 4 at (0,1), 5 at (1,2), 6 at (2,0) in a 3x3 matrix.

2. Step 2: Construct full matrix

   Positions without data are zero, so matrix is [[0 4 0], [0 0 5], [6 0 0]].

3. Final Answer:

   [[0 4 0] [0 0 5] [6 0 0]] -> Option A

4. Quick Check:

   Data at (row,col) = matrix entries [OK]

Hint: Match data with (row, col) indices to build matrix [OK]

Common Mistakes:

• Mixing row and column indices
• Assuming data fills diagonal
• Confusing CSR/CSC formats with COO

4. Identify the error in this code snippet:

from scipy.sparse import coo_matrix
row = [0, 1]
col = [1, 2]
data = [3, 4]
sparse = coo_matrix(data, (row, col))

medium

A. coo_matrix does not accept data with length 2

B. row and col should be numpy arrays, not lists

C. The shape parameter is missing

D. The data and indices should be passed as a single tuple

Solution

1. Step 1: Check coo_matrix constructor usage

   coo_matrix expects a single tuple (data, (row, col)) as first argument.

2. Step 2: Identify mistake in code

   Code passes data and (row, col) as separate arguments, causing error.

3. Final Answer:

   The data and indices should be passed as a single tuple -> Option D

4. Quick Check:

   coo_matrix((data, (row, col))) required [OK]

Hint: Pass data and indices as one tuple to coo_matrix [OK]

Common Mistakes:

• Passing data and indices as separate arguments
• Forgetting to wrap indices in a tuple
• Assuming lists cause error instead of argument structure

5. You have a large dataset with many zero values. You want to create a sparse matrix for fast arithmetic operations. Which format should you choose and why?

Options:
A) CSR format, because it is efficient for arithmetic and slicing
B) COO format, because it is efficient for arithmetic
C) DOK format, because it uses dictionary storage
D) LIL format, because it is best for matrix multiplication

hard

A. DOK format, because it uses dictionary storage

B. COO format, because it is efficient for arithmetic

C. CSR format, because it is efficient for arithmetic and slicing

D. LIL format, because it is best for matrix multiplication

Solution

1. Step 1: Understand sparse matrix formats

   COO is good for building matrices, CSR is efficient for arithmetic and slicing.

2. Step 2: Choose format for fast arithmetic

   CSR format supports fast arithmetic operations and efficient row slicing, ideal for large data.

3. Final Answer:

   CSR format, because it is efficient for arithmetic and slicing -> Option C

4. Quick Check:

   CSR = fast arithmetic and slicing [OK]

Hint: Use CSR for fast math and slicing on sparse data [OK]

Common Mistakes:

• Choosing COO for arithmetic instead of CSR
• Confusing DOK with arithmetic efficiency
• Assuming LIL is best for multiplication