Session 4 - Part 2 Flashcards
Although we are processed small amounts of data like single numbers or long lists, neuroimagning data however,
contains millions of numbers and processing these one ar a time with loops is not going to work
For larger scale data analysis (usually with neuroimagning data) we can use pre-existing modules and core tool for this in Python is
numpy
Numpy works with
large blocks of numbers called ‘matrices’ (or sometimes ‘arrays’)
Matrices are often rectangular blocks that are
stored as rows x columns
Matrices are often rectangular blocks that are stored as rows x columns.
For instance:
3 rows by 2 columns so it would have shape (3, 2).
The order of the dimensions of matrices is always
(rows, columns).
For most of the time we will be working with 2D matrices, however numpy will cope with any number of dimension from
(from 1D up to any number of dimensions).
Matrices are usually two-dimensional whereas arrays can be
have any number of dimensions
when performing addition, subtraction, multiplication, or division on matrices, they must be of
he same size, meaning they must have the same number of rows and columns.
Example of addition of matrices
Example of subtraction of matrices:
Example of multiplication and division of matrices - element by element mulplication/division|
numpy and scipy are two modules that support for much of the
scientific work that you will want to do in Python
numpy provides “low-level” routines for manipulating matrices like
linear algebra routines (e.g. inverting a matrix), Fourier transforms and random number capabilities (using a range of distributions).
scipy provides “higher-level” routines for science and engineering and uses numpy as base and then adds
additional algorithms for things like image and signal processing.
matplotlib is a
plotting library that lets you produce a range of different graphs
Numpy uses the numpy.array class to store
arrays of numbers
Numpy arrays can be any
number of dimensions and any size
Python is a 0-indexed language. This means that if we have a2x2 array
the two rows are referred to using indices 0 and 1 and the two columns are referred to using indices 0 and 1.
When indexing into numpy arrays, we use
square brackets (similar to lists).
We can also use a range separated by a colon (:) in array which is exclusive of last number (similar to range function) e.g., - (2)
data[0:100, 0:100] This gives us a 100x100 subarray of the data array
data[50:, :] This gives us the 51st row onwards and all of the columns –> In Python, indexing starts from 0, so the 51st row corresponds to index 50. T
Explain the code please - (5)
import numpy as np: This line imports the NumPy library and aliases it as np, allowing us to refer to NumPy functions and objects using the shorter name np.
z = np.zeros((2, 3)): This line creates a 2x3 matrix filled with zeros.
The numbers (2, 3) inside the parentheses represent the dimensions of the matrix, with 2 rows and 3 columns.
print(‘Here is an array of zeros’): This line prints a descriptive message to indicate that the following array contains all zeros.
print(z): This line prints the array z containing zeros to the console.
What is the output of the code?
Here is an array of zeros
[[0. 0. 0.]
[0. 0. 0.]]
What does z[0, 0] = 1.0 do? - (2)
z = np.zeros((2,3)) producign 2x3 matrix of zeros
This line sets the element at the first row and first column of the matrix z to 1.0.
In other words, it modifies the top-left element of the matrix.
What does z[0, :] = 2.0 - (2)
z = np.zeros((2,3)) producign 2x3 matrix of zeros
This line sets all elements in the first row (all columns) of the matrix z to 2.0.
It fills the entire first row with the value 2.0.
What does z[:, 1] = 3.0- (2)
z = np.zeros((2,3)) producign 2x3 matrix of zeros
This line sets all elements in the second column (all rows) of the matrix z to 3.0.
It fills the entire second column with the value 3.0.
What does z[0, :] = 2.0 - (2)
z = np.zeros((2,3)) producign 2x3 matrix of zeros
This line sets all elements in the first row (all columns) of the matrix z to 2.0.
It fills the entire first row with the value 2.0.
What does z[:, 1] = 3.0- (2)
z = np.zeros((2,3)) producign 2x3 matrix of zeros
This line sets all elements in the second column (all rows) of the matrix z to 3.0.
It fills the entire second column with the value 3.0.
What does single_num = z[0,1] do if we print it out? - (2)
z = np.zeros((2,3)) producing 2x3 matrix of zeros
Extracts a single number from the first row and first column of the matrix
The item at z[0,1] is 0.0
What does a_row = z[0,:] do if we print it out? - (3)
z = np.zeros((2,3)) producing 2x3 matrix of zeros
In the context of array indexing in NumPy, the comma separates the row index from the column index.
In this expression, z[0, :], 0 indicates the row index (specifically the first row), and : indicates that all columns in that row are selected.
Output:
[0. 0. 0.]
So with matrices we can set
certain elements to be certain values as well as extract single and multiple numbers
What does rArray=np.random.rand(200,200) do?
This line initializes a NumPy array named rArray with dimensions 200x200 filled with random numbers generated using np.random.rand().
What does print(f’Array size={rArray.size}’) display?
if rArray=np.random.rand(200,200)
This line prints the total number of elements in the rArray array which is 4000
What does rint(f’Array shape={rArray.shape}’)display?
if rArray=np.random.rand(200,200) - (2)
This line prints the shape of the rArray array, which represents its dimensions as a tuple (rows, columns)
output: Array shape=(200, 200)
What does smallerArray=rArray[0:100,0:100] do
if rArray = np.random.rand(200,200)
This line creates a subset of the rArray array, selecting rows from index 0 to 99 and columns from index 0 to 99, effectively creating a smaller 100x100 array from the original 200x200 array.
: How can the size parameter in np.zeros be represented, according to the comment # The size thing here is a tuple - it can also be a list?
The size parameter in np.zeros can be represented as either a tuple or a list, allowing flexibility in specifying the dimensions of the array to be created.
Explain the code - (4)
import numpy as np
z = np.zeros((2, 3)) # The size thing here is a tuple - it can also be a list
print(‘Here is an array of zeros’)
print(z) #array of 2x3 zeros
print(‘Now I set the bottom right element (1,2) to 9’)
z[1,2]=9 #Work out how to do this
print(z [1,:])
This code snippet begins by importing the NumPy library and aliasing it as np.
It then initializes a 2x3 NumPy array named z filled with zeros.
The line z[1, 2] = 9 modifies the bottom-right element of the array to 9.
Finally, it prints the second row of the array using print(z[1, :]), where z[1, :] selects the entire second row of the array.
What is the output of this code?
import numpy as np
z = np.zeros((2, 3)) # The size thing here is a tuple - it can also be a list
print(‘Here is an array of zeros’)
print(z) #array of 2x3 zeros
print(‘Now I set the bottom right element (1,2) to 9’)
z[1,2]=9 #Work out how to do this
print(z [1,:])
What does the comment mean: # The size thing here is a tuple - it can also be a list - (4)
refers to the argument passed to np.zeros(), which specifies the dimensions of the array.
In Python, dimensions are often represented as tuples, where the first element indicates the number of rows and the second element indicates the number of columns.
However, this argument could also be provided as a list.
Explain what this code does - (3)
his code imports the NumPy library with the alias np
a 3x4 matrix filled with ones using the np.ones function and stores it in the variable o.
Finally, it prints the contents of the o matrix to the output console.
What is the output of this code?
Explain this code - (3)
This code imports the NumPy library as np and creates a 2x4 NumPy array named “a” by converting a list of lists into an array.
The array contains the elements [[1, 2, 3, 8], [4, 5, 6, 9]].
Finally, it prints out the array “a”.
What is the output of this code?
Explain thsi code - (4)
This code initializes a NumPy array a with integer values in a 2x3 format, meaning it has 2 rows and 3 columns.
Then, it uses the astype method to explicitly cast the data type of the array a to float.
This operation overrides the original array a and changes its data type from integer to float.
Finally, it prints the modified array a, now containing floating-point values.
Explain this code - (4)
This code initializes a NumPy array a with values in a 2x3 format.
It specifies the data type of the array as int, which forces all elements to be integers, even if they were floats initially.
This is achieved using the dtype=int parameter in the np.array function call.
Finally, it prints the resulting array a.
What is output of the code going to be - going to be same even if its 3.6 instead of 3.6
Example of converting list to numpy array
What will be output of the code?
Explain this code - (4):
This code first imports the NumPy library and then defines a list of numbers (my_numbers) containing two sub-lists.
Next, it converts the list my_numbers into a NumPy array using the np.array() function which is stored in variable ‘a’
The resulting array a is a 2D array with the same structure as the original list and a size of 2x3 (2 rows and 3 columns).
Finally, it prints the array a,
Explain this code - (3)
In the first example (a = np.arange(3)), it creates an array containing numbers from 0 up to (but not including) 3.
In the second example (b = np.arange(1, 3)), it creates an array containing numbers from 1 up to (but not including) 3.
In the third example (c = np.arange(1, 3, 0.5)), it creates an array containing numbers from 1 up to (but not including) 3, with a step size of 0.5,
What would be the output of this code?
Explain the code snippet (output attached) - (4)
This code snippet first imports the matplotlib.pyplot module and the numpy module as plt and np,
respectively.
It then generates an array of ‘x’ values from 1 to 5 with a step size of 1 using np.arange(1, 6, 1).
Next, it calculates ‘y’ values by squaring each ‘x’ value.
Finally, it plots the data with ‘x’ values on the x-axis and ‘y’ values on the y-axis using plt.plot() and displays the plot using plt.show().
Modify the code below to plot a nice smooth cubic function (x to the power of 3) between -5 and 5 with exactly 100 steps:
Explain this code - (4)
This code snippet imports the matplotlib.pyplot module and the numpy module as plt and np, respectively.
It then generates an array x containing 100 equally spaced numbers between -5 and 6 using np.linspace(-5, 6, 100).
Next, it calculates ‘y’ values by cubing each ‘x’ value.
Finally, it plots the data with ‘x’ values on the x-axis and ‘y’ values on the y-axis using plt.plot(), adds gridlines to the plot using plt.grid(True), and displays the plot using plt.show().
Output of 1D array vs 2D array:
What does the following code snippet do? - (2)
import numpy as np
r = np.random.rand(2, 2)
print(r)
This code snippet uses np.random.rand() to generate a 2D array r with 2 rows and 2 columns, filled with random numbers between 0 and 1.
It then prints the generated array r
Explain this code - (4)
This code snippet generates a 20x20 array of random numbers between 0 and 1 using np.random.rand().
It then displays the array r as an image using plt.imshow(), with colors representing the values of the numbers (When displaying numerical data as an image, each numerical value in the array is mapped to a color)
Additionally, it adds a color bar to the side of the plot using plt.colorbar(), which helps interpret the colors.
Finally, it displays the plot using plt.show().
All of the generated numbers here lie between 0 and 1 (as well as colour bar runs from 0 to1)
Each number is equally likely to be chosen - we say that the distribution is ‘uniform’.
Explain this code snippet - (4)
This code snippet generates a 50x50 array of random numbers drawn from a normal distribution using np.random.randn().
It then displays the array rn as an image using plt.imshow(), with colors representing the values of the numbers.
Additionally, it adds a color bar to the side of the plot using plt.colorbar(), which helps interpret the colors.
Finally, it displays the plot using plt.show().
Explain this code - (3) - assuming previous code of defining ‘r’ and ‘rn’ and producing their graphs
fig,a = plt.subplots(1,2)
fig,a = plt.subplots(1,2)
a[0].imshow(rn) #This function shows your normal-random array as an image
a[1].imshow(r) #This function shows your uniform-random array as an image
fig, a = plt.subplots(1, 2): This line creates a figure with two subplots arranged side by side. The subplots() function returns a figure (fig) and an array of axes (a). In this case, 1 indicates that there is only one row of subplots, and 2 indicates that there are two subplots in total (side by side).
a[0].imshow(rn): This line displays the first subplot (a[0]) and shows the normal-random array rn as an image using the imshow() function. a[0] refers to the first subplot created by plt.subplots(), and imshow() is a function used to display arrays as images.
a[1].imshow(r): This line displays the second subplot (a[1]) and shows the uniform-random array r as an image using the imshow() function. a[1] refers to the second subplot created by plt.subplots().
Explain this code - (5)
This code snippet assumes that rn and r have been defined previously as arrays representing different types of random numbers.
It creates a figure with two subplots arranged side by side using plt.subplots(1, 2).
In the first subplot (a[0]), it computes and displays a histogram of all numbers in the array rn after flattening it into a 1D list using flatten(). The histogram is computed with 50 bins.
In the second subplot (a[1]), it computes and displays a histogram of all numbers in the array r. Similar to the first subplot, the histogram is computed with 50 bins.
This allows for a visual comparison of the distributions of two arrays, which may represent different types of random numbers.
What will be output of the code?
import numpy as np
a=np.array([[1,2],[3,4]])
b=np.array([[5,6],[7,8]])
c=a+b # Adding two arrays which are the same size
d=a*10 # Multiplying a single array by a scalar
print(a)
print(b)
print(c)
print(d)
What does the following code snippet do? - (3)
a_mean = a.mean()
print(a_mean)
a_sd = a.std()
print(a_sd)
a_var = a.var()
print(a_var)
a_mean = a.mean() calculates the mean (average) of the numbers in array ‘a’ and assigns it to the variable ‘a_mean’. The mean is then printed.
a_sd = a.std() computes the sample standard deviation of the numbers in array ‘a’ and assigns it to the variable ‘a_sd’. The standard deviation is then printed.
a_var = a.var() determines the sample variance of the numbers in array ‘a’ and assigns it to the variable ‘a_var’. The variance is then printed.
