# Python plot 4d array

• 3D Surface plotting in Python using Matplotlib
• Visualization of Multidimensional Datasets Using t-SNE in Python
• From Python Nested Lists to Multidimensional numpy Arrays
• Scatter Plot
• ## 3D Surface plotting in Python using Matplotlib

This blog post acts as a guide to help you understand the relationship between different dimensions, Python lists, and Numpy arrays as well as some hints and tricks to interpret data in multiple dimensions. We provide an overview of Python lists and Numpy arrays, clarify some of the terminologies and give some helpful analogies when dealing with higher dimensional data.

So this blog post is expanded from our introductory course on Python for Data Science and help you deal with nesting lists in python and give you some ideas about numpy arrays. Nesting involves placing one or multiple Python lists into another Python list, you can apply it to other data structures in Python, but we will just stick to lists. Lists and 1-D Numpy Arrays Lists are a useful datatype in Python; lists can be written as comma separated values. You can change the size of a Python list after you create it and lists can contain an integer, string, float, Python function and Much more.

Indexing for a one-dimensional 1-D list in Python is straightforward; each index corresponds to an individual element of the Python list. Similarly, the value of A[4] is an integer 4. For the rest of this blog, we are going to stick with integer values and lists of uniform size as you may see in many data science applications.

Some key differences between lists include, numpy arrays are of fixed sizes, they are homogenous I,e you can only contain, floats or strings, you can easily convert a list to a numpy array, For example, if you would like to perform vector operations you can cast a list to a numpy array.

For example, v. In numpy dimension or axis are better understood in the context of nesting, this will be discussed in the next section. It should be noted the sometimes the data attribute shape is referred to as the dimension of the numpy array. The numpy array has many useful properties for example vector addition, we can add the two arrays as follows: Example 2: add numpy arrays u and v to form a new numpy array z.

The actual vector operation is shown in figure 2, where each component of the vector has a different color. Many of the operations of numpy arrays are different from vectors, for example in numpy multiplication does not correspond to dot product or matrix multiplication but element-wise multiplication like Hadamard product, we can multiply two numpy arrays as follows: Example 3.

Nesting lists and two 2-D numpy arrays Nesting two lists are where things get interesting, and a little confusing; this 2-D representation is important as tables in databases, Matrices, and grayscale images follow this convention. When each of the nested lists is the same size, we can view it as a 2-D rectangular table as shown in figure 5.

Each list is a different row in the rectangular table, and each column represents a separate element in the list. In this case, we set the elements of the list corresponding to row and column numbers respectively. This indexing convention to access each element of the list is shown in figure 6, the top part of the figure corresponds to the nested list, and the bottom part corresponds to the rectangular representation.

We can also view the nesting as a tree as we did in Python for Data Science as shown in figure 5 The first index corresponds to a first level of the tree, the second index corresponds to the second level.

For example, we can convert the following nested list into a 2-D array: Example 4: creating a 2-D array or array with two access The convention for indexing is the exact same, we can represent the array using the table form like in figure 5.

In numpy the dimension of this array is 2, this may be confusing as each column contains linearly independent vectors. In numpy, the dimension can be seen as the number of nested lists.

The 2-D arrays share similar properties to matrices like scaler multiplication and addition. For example, adding two 2-D numpy arrays corresponds to matrix addition. Example 5. Similarly, multiplication of two arrays corresponds to an element-wise product: Example 5. To perform standard matrix multiplication you world use np. In the next section, we will review some strategies to help you navigate your way through arrays in higher dimensions.

Nesting List within a List within a List and 3-D Numpy Arrays We can nest three lists, each of these lists intern have nested lists that have there own nested lists as shown in figure You can access the first, second and third list using A[0], A[1] and A[2] respectively. Each of these lists contains a list of three nested lists. We can represent these nested lists as a rectangular table as shown in figure The indexing conventions apply to these lists as well we just add a third bracket, this is also demonstrated in the bottom of figure 6 where the three rectangular tables contain the syntax to access the values shown in the table above.

Figure 12 shows an example to access elements at index A[0][2][1] which contains a value of The first index A[0] contains a list that contains three lists, which can be represented as a rectangular table. We use the second index i. In the table representation, this corresponds to the last row of the table. The list A[0][2] corresponds to the list [,,]. As we are interested in accessing the second element we simply append the index [1]; Therefore the final result is A[0][2][1].

The first index of the list represents the address on the road, in Figure 8 this is shown as depth. The second index of the list represents the floor where the room is situated, depicted by the vertical direction in Figure To keep consistent with our table representation the lower levels have a larger index.

Finally, the last index of the list corresponds to the room number on a particular floor, represented by the horizontal arrow. In the figures, X, Y first index or dimension corresponds an element in the square brackets but instead of a number, we have a rectangular array.

When the add or multiply X and Y together each element is added or multiplied together independently. More precisely each 2D arrays represented as tables is X are added or multiplied with the corresponding arrays Y as shown on the left; within those arrays, the same conventions of 2D numpy addition is followed. The third element A[2] contains 2 lists; this list contains two lists in figure 10 we use the depth to distinguish them.

We can access the second list using the second index as follows A[2][1]. This can be viewed as a table, from this point we follow the table conventions for the previous example as illustrated in figure As before the second list index represents the address, the third list index represents the floor number and the fourth index represents the apartment number.

The analogy is summarized in Figure For example directions to element A[2][1][0][0] would be 2nd Street , Building 1, Floor 0 room 0. Similarly, a Numpy array is a more widely used method to store and process data.

In both cases, you can access each element of the list using square brackets. Although Numpy arrays behave like vectors and matrices, there are some subtle differences in many of the operations and terminology.

Conclusion Introduction The way we think about graphs and visualization is usually in 2D and 3D spaces. From high school onward we work with plotting the data in XY planes and XYZ spaces which make perfect sense to us. Yet, when working with majority of datasets in the real world, we find that most of them have more than 3 features, hence are multidimensional. And now comes the struggle of visualizing the data in k-dimensions simply because we see and think in 3D in out daily lives.

There are a lot of articles in the data science online communities focusing on data visualization and understanding the multidimensional datasets.

I personally read several articles describing the algebra and geometry behind the 4D spaces and up to this day find it difficult to visualize in my head, not to even mention the larger dimensions.

The idea behind dimensionality reduction in this case has two key components: Help make the data more algorithm friendly Help make the data reshaped in order to visualize it The first part is more of a mathematical approach and is needed for algorithm development and other machine learning work, for example, principal component analysis.

In this article, we will focus on the second part. Our goal is to make a multidimensional dataset more friendly for visualization. There are also several approaches to solve this, but here we will work with t-SNE. It is very useful for reducing k-dimensional datasets to lower dimensions two- or three-dimensional space for the purposes of data visualization.

The approach of SNE is: Construct a probability distribution to represent the dataset, where similar points have a higher probability of being picked, and dissimilar points have a lower probability of being picked.

Create a low dimensional space that replicates the properties of the probability distribution from Step 1 as close as possible. Step 1 : Conditional probability in high dimensional space Depending on the statistical knowledge of the reader it can be easy or difficult to understand.

Further we will show exactly how this transformation is performed using formulas and references from one of the most popular papers regarding the details of SNE. How do we determine which points are similar and which are dissimilar?

In Stochastic Neighbor Embedding, similar points are points with high conditional probability. These are the two random points we chose from the dataset in the model, it calculates the conditional probability for all pairs of points in the dataset. Step 2: Conditional probability in low dimensional space In the previous part we found potential neighbors based on similarity in k-dimensional space. Now we need to find their counterparts in the lower dimensional space. This technique employs the minimization of Kullback-Leiber divergence in order to arrive at its results.

What it does is it minimizes the different between two probability distributions. Summary The above sections show the logic and the calculations that take place behind Stochastic Neighbor Embedding. Recall the steps we used for SNE: Create a probability distribution defining relationships between data points in k-dimensional space using Gaussian normal distribution. Recreate a probability distribution defining relationships between data counterparts in lower dimensional space using Gaussian normal distribution.

What are the drawbacks of this approach? It minimizes the Kullback-Leiber divergence which has a cost function that is difficult to optimize. In the previous section with SNE calculations we worked with Gaussian normal distribution and the gradient descent cost function that minimizes the Kullback-Lieber divergence. The approach of t-SNE is: Create a probability distribution defining relationships between data points in k-dimensional space using Gaussian normal distribution.

Step 1 : Conditional probability in high dimensional space This step is identical to Step 1 in the previous section. The formula for conditional probability will have some minor differences due to the symmetric SNE approach and is described in detail in the original paper.

We will be using student t-distribution to take advantage of its heavy tails in lower dimension. But why do we need this modified version? Addition What is more interesting to us is the crowding problem. The crowding problem is essentially the inability to preserve distances between data points that you have in higher dimensions when converting it to a lower dimension.

Your points have the following coordinates: 0, 0 , -1, -1 , 1, -1 , 1, 1 , -1, 1. The next step you want to do is to convert it to a 1D space. What happens in the lower dimension is that there is less space to fit all the data from higher dimension. In the graph above we see that there are 5 points and each has its own place. This is called the crowding problem.

This technique employs the minimization of Kullback-Leiber divergence in order to arrive at its results. What it does is it minimizes the different between two probability distributions. Summary The above sections show the logic and the calculations that take place behind Stochastic Neighbor Embedding. Recall the steps we used for SNE: Create a probability distribution defining relationships between data points in k-dimensional space using Gaussian normal distribution.

Recreate a probability distribution defining relationships between data counterparts in lower dimensional space using Gaussian normal distribution. What are the drawbacks of this approach? It minimizes the Kullback-Leiber divergence which has a cost function that is difficult to optimize.

In the previous section with SNE calculations we worked with Gaussian normal distribution and the gradient descent cost function that minimizes the Kullback-Lieber divergence.

## Visualization of Multidimensional Datasets Using t-SNE in Python

The approach of t-SNE is: Create a probability distribution defining relationships between data points in k-dimensional space using Gaussian normal distribution. Step 1 : Conditional probability in high dimensional space This step is identical to Step 1 in the previous section.

The formula for conditional probability will have some minor differences due to the symmetric SNE approach and is described in detail in the original paper.

We will be using student t-distribution to take advantage of its heavy tails in lower dimension. But why do we need this modified version? By examining the above scatter plot we see an overall positive correlation between petal length and petal width for the three species. Multidimensional Scatter Plot Scatter plot is a two dimensional visualization tool, but we can easily add another dimension to the 2D plot using the visual variables such as the color, size and shape.

Say for example, you want to see the correlation between three variables then you can map the third variable to the marker size of each data point in the plot. So the marker size represents an additional third dimension. We can plot all the data points with the same color by specifying a color name or we can plot data points in varying colors.

For example, we can change the color intensity of the data points from bright to dark, in this case color for each data point is retrieved from a color map. Color map also called a color look up table, is a three-column matrix whose length is equal to the number of colors it defines.

Each row of the matrix defines a particular color by specifying three values in the range 0 to 1. The numpy array has many useful properties for example vector addition, we can add the two arrays as follows: Example 2: add numpy arrays u and v to form a new numpy array z.

The actual vector operation is shown in figure 2, where each component of the vector has a different color.

### From Python Nested Lists to Multidimensional numpy Arrays

Many of the operations of numpy arrays are different from vectors, for example in numpy multiplication does not correspond to dot product or matrix multiplication but element-wise multiplication like Hadamard product, we can multiply two numpy arrays as follows: Example 3. Nesting lists and two 2-D numpy arrays Nesting two lists are where things get interesting, and a little confusing; this 2-D representation is important as tables in databases, Matrices, and grayscale images follow this convention.

When each of the nested lists is the same size, we can view it as a 2-D rectangular table as shown json colors figure 5. Each list is a different row in the rectangular table, and each column represents a separate element in the list. In this case, we set the elements of the list corresponding to row and column numbers respectively.

This indexing convention to access each element of the list is shown in figure 6, the top part of the figure corresponds to the nested list, and the bottom part corresponds to the rectangular representation.

We can also view the nesting as a tree as we did in Python for Data Science as shown in figure 5 The first index corresponds to a first level of the tree, the second index corresponds to the second level.

For example, we can convert the following nested list into a 2-D array: Example 4: creating a 2-D array or array with two access The convention for indexing is the exact same, we can represent the array using the table form like in figure 5. In numpy the dimension of this array is 2, this may be confusing as each column contains linearly independent vectors. In numpy, the dimension can be seen as the number of nested lists.

### Scatter Plot

The 2-D arrays share similar properties to matrices like scaler multiplication and addition. For example, adding two 2-D numpy arrays corresponds to matrix addition. Example 5. Similarly, multiplication of two arrays corresponds to an element-wise product: Example 5. To perform standard matrix multiplication you world use np. In the next section, we will review some strategies to help you navigate your way through arrays in higher dimensions. Nesting List within a List within a List and 3-D Numpy Arrays We can nest three lists, each of these lists intern have nested lists that have there own nested lists as shown in figure

## thoughts on “Python plot 4d array”

1. Moogujin says:

It is reserve, neither it is more, nor it is less