Develop Reference

Confusion matrix: ValueError: Classification metrics can't handle a mix of multiclass and continuous-multioutput targets

I'm working on a multiclass classification problem (12 classes), but I can't create the confusion matrix.
What I'm trying to do is:
from sklearn.metrics import multilabel_confusion_matrix
pred = model_BiLSTM.predict(X_val)
y_unique = np.unique(y_val)
mcm =confusion_matrix(y_val, pred, labels = y_unique)
But as per the title, the returned error is: "ValueError: Classification metrics can't handle a mix of multiclass and continuous-multioutput targets", and the same happens when using confusion_matrix().
Instead, this is the output of
y_val, pred, y_val.shape, pred.shape
16/16 [==============================] - 0s 6ms/step
(array([11, 8, 3, 3, 9, 9, 9, 3, 3, 1, 3, 6, 6, 6, 2, 9, 1,
3, 10, 6, 9, 2, 9, 4, 3, 9, 6, 9, 3, 3, 3, 3, 8, 1,
9, 9, 9, 9, 2, 1, 9, 3, 9, 3, 9, 9, 2, 10, 3, 2, 9,
3, 8, 6, 8, 9, 9, 6, 6, 9, 8, 7, 9, 2, 9, 9, 2, 3,
9, 9, 2, 6, 3, 7, 11, 9, 9, 2, 11, 6, 7, 11, 6, 9, 2,
6, 9, 2, 9, 9, 3, 6, 9, 1, 11, 4, 4, 2, 6, 2, 9, 3,
10, 3, 2, 9, 9, 10, 6, 3, 9, 9, 6, 8, 6, 9, 4, 6, 5,
9, 6, 6, 3, 3, 3, 9, 6, 2, 9, 11, 6, 9, 3, 9, 6, 9,
2, 9, 3, 9, 6, 1, 6, 9, 9, 8, 3, 2, 9, 2, 8, 9, 9,
3, 10, 2, 4, 9, 9, 2, 8, 3, 6, 9, 9, 9, 6, 2, 2, 9,
7, 9, 3, 6, 7, 2, 9, 2, 9, 10, 9, 2, 9, 5, 7, 6, 5,
6, 3, 9, 7, 9, 3, 11, 5, 3, 3, 0, 8, 3, 9, 5, 9, 10,
9, 3, 3, 11, 2, 1, 8, 6, 2, 9, 3, 6, 2, 8, 9, 2, 8,
3, 3, 9, 6, 2, 1, 9, 9, 2, 2, 10, 9, 1, 6, 9, 9, 2,
9, 5, 6, 3, 9, 7, 6, 9, 9, 6, 3, 3, 2, 3, 9, 6, 9,
9, 9, 9, 9, 9, 9, 2, 9, 9, 9, 9, 3, 1, 6, 6, 6, 10,
9, 9, 9, 2, 9, 2, 3, 9, 9, 10, 6, 10, 6, 1, 1, 6, 1,
6, 3, 4, 6, 1, 11, 3, 9, 9, 4, 9, 9, 5, 8, 3, 5, 9,
6, 9, 9, 9, 3, 2, 5, 1, 9, 6, 1, 3, 9, 5, 3, 9, 6,
7, 2, 9, 9, 3, 5, 9, 6, 6, 3, 1, 9, 3, 9, 7, 9, 9,
7, 9, 10, 2, 9, 4, 9, 9, 9, 3, 9, 5, 3, 2, 9, 3, 8,
2, 9, 3, 11, 3, 3, 9, 2, 10, 9, 3, 9, 1, 9, 10, 5, 1,
2, 5, 9, 2, 3, 5, 9, 4, 8, 9, 5, 10, 3, 2, 6, 3, 6,
10, 11, 3, 6, 9, 3, 3, 0, 6, 7, 8, 9, 6, 5, 3, 1, 9,
2, 9, 9, 5, 2, 5, 3, 6, 11, 2, 9, 3, 6, 2, 9, 9, 3,
3, 3, 5, 6, 4, 4, 9, 2, 2, 5, 1, 0, 9, 4, 3, 3, 9,
9, 5, 2, 2, 2, 5, 7, 9, 3, 9, 9, 1, 2, 9, 6, 8, 2,
3, 4, 2, 3, 3, 2, 6, 5, 9, 5, 2, 2, 2, 9, 9, 6, 2,
9, 4, 9, 9, 2, 3, 8, 11, 9, 9], dtype=int32),
array([[5.7949889e-03, 2.5301890e-03, 5.9659913e-05, ..., 2.7534673e-03,
1.8798949e-03, 4.0977496e-01],
[2.1629781e-04, 1.0219574e-02, 1.2285617e-03, ..., 4.0498661e-04,
3.6948815e-04, 8.3618681e-04],
[8.1547890e-03, 1.1354284e-04, 1.3678521e-04, ..., 3.6535120e-01,
1.1546685e-03, 3.5349184e-03],
...,
[1.1976730e-03, 6.8558909e-02, 8.7605380e-03, ..., 1.7384565e-01,
5.4570078e-04, 2.0005915e-02],
[2.1097453e-02, 7.7744485e-03, 2.5690982e-01, ..., 5.4854238e-01,
3.9467164e-03, 1.6034273e-02],
[2.0812787e-03, 1.6885218e-05, 4.7070305e-05, ..., 4.3611538e-01,
3.6522493e-04, 1.4385413e-02]], dtype=float32),
(486,),
(486, 12))
If it helps, this is my model:
def build_BiLSTM_classifier(input_shape, classes):
input_layer = tfkl.Input(shape=input_shape, name='Input')
bilstm = tfkl.Bidirectional(tfkl.LSTM(128, return_sequences=True))(input_layer)
bilstm = tfkl.Bidirectional(tfkl.LSTM(128))(bilstm)
dropout = tfkl.Dropout(.5, seed=seed)(bilstm)
classifier = tfkl.Dense(128, activation='tanh')(dropout)
output_layer = tfkl.Dense(classes, activation='softmax')(classifier)
model = tfk.Model(inputs=input_layer, outputs=output_layer, name='model')
model.compile(loss=tfk.losses.SparseCategoricalCrossentropy(), optimizer=tfk.optimizers.Adam(), metrics='accuracy')
return model
What could I try to do?

Your pred array appears to contain class scores rather than predictions. Try pred.argmax(axis=1) instead.

Python: How to efficiently create all possible 2 element swaps of an array?

I try to generate all possible 2-element swaps of a given array.
For example:
candidate = [ 5, 9, 1, 8, 3, 7, 10, 6, 4, 2]
result = [[ 9, 5, 1, 8, 3, 7, 10, 6, 4, 2]
[ 1, 9, 5, 8, 3, 7, 10, 6, 4, 2]
[ 8, 9, 1, 5, 3, 7, 10, 6, 4, 2]
[ 3, 9, 1, 8, 5, 7, 10, 6, 4, 2]
[ 7, 9, 1, 8, 3, 5, 10, 6, 4, 2]
[10, 9, 1, 8, 3, 7, 5, 6, 4, 2]
[ 6, 9, 1, 8, 3, 7, 10, 5, 4, 2]
[ 4, 9, 1, 8, 3, 7, 10, 6, 5, 2]
[ 2, 9, 1, 8, 3, 7, 10, 6, 4, 5]
[ 5, 1, 9, 8, 3, 7, 10, 6, 4, 2]
[ 5, 8, 1, 9, 3, 7, 10, 6, 4, 2]
[ 5, 3, 1, 8, 9, 7, 10, 6, 4, 2]
[ 5, 7, 1, 8, 3, 9, 10, 6, 4, 2]
[ 5, 10, 1, 8, 3, 7, 9, 6, 4, 2]
[ 5, 6, 1, 8, 3, 7, 10, 9, 4, 2]
[ 5, 4, 1, 8, 3, 7, 10, 6, 9, 2]
[ 5, 2, 1, 8, 3, 7, 10, 6, 4, 9]
[ 5, 9, 8, 1, 3, 7, 10, 6, 4, 2]
[ 5, 9, 3, 8, 1, 7, 10, 6, 4, 2]
[ 5, 9, 7, 8, 3, 1, 10, 6, 4, 2]
[ 5, 9, 10, 8, 3, 7, 1, 6, 4, 2]
[ 5, 9, 6, 8, 3, 7, 10, 1, 4, 2]
[ 5, 9, 4, 8, 3, 7, 10, 6, 1, 2]
[ 5, 9, 2, 8, 3, 7, 10, 6, 4, 1]
[ 5, 9, 1, 3, 8, 7, 10, 6, 4, 2]
[ 5, 9, 1, 7, 3, 8, 10, 6, 4, 2]
[ 5, 9, 1, 10, 3, 7, 8, 6, 4, 2]
[ 5, 9, 1, 6, 3, 7, 10, 8, 4, 2]
[ 5, 9, 1, 4, 3, 7, 10, 6, 8, 2]
[ 5, 9, 1, 2, 3, 7, 10, 6, 4, 8]
[ 5, 9, 1, 8, 7, 3, 10, 6, 4, 2]
[ 5, 9, 1, 8, 10, 7, 3, 6, 4, 2]
[ 5, 9, 1, 8, 6, 7, 10, 3, 4, 2]
[ 5, 9, 1, 8, 4, 7, 10, 6, 3, 2]
[ 5, 9, 1, 8, 2, 7, 10, 6, 4, 3]
[ 5, 9, 1, 8, 3, 10, 7, 6, 4, 2]
[ 5, 9, 1, 8, 3, 6, 10, 7, 4, 2]
[ 5, 9, 1, 8, 3, 4, 10, 6, 7, 2]
[ 5, 9, 1, 8, 3, 2, 10, 6, 4, 7]
[ 5, 9, 1, 8, 3, 7, 6, 10, 4, 2]
[ 5, 9, 1, 8, 3, 7, 4, 6, 10, 2]
[ 5, 9, 1, 8, 3, 7, 2, 6, 4, 10]
[ 5, 9, 1, 8, 3, 7, 10, 4, 6, 2]
[ 5, 9, 1, 8, 3, 7, 10, 2, 4, 6]
[ 5, 9, 1, 8, 3, 7, 10, 6, 2, 4]]
I currently achive this by using two nested for-loops:
neighborhood = []
for node1 in range(candidate.size - 1):
for node2 in range(node1 + 1, candidate.size):
neighbor = np.copy(candidate)
neighbor[node1] = candidate[node2]
neighbor[node2] = candidate[node1]
neighborhood.append(neighbor)
The larger the array gets, the more inefficient and slower it becomes. Is there a more efficient way here that can also process arrays with three-digit contents?
Thank you!

You can use a generator if you need to use those arrays one by one (in this way, you don't need to memorize them all, you need very little space):
from itertools import combinations
def gen(lst):
for i, j in combinations(range(len(lst)), 2):
yield lst[:i] + lst[j] + lst[i:j] + lst[i] + lst[j:]
And then you can use it in this way:
for lst in gen(candidate):
# do something with your list with two swapped elements
This is going to save much space, but it's probably going to be still slow overall.
Here is a solution using NumPy. This is not space efficient (because it's memorizing all possible lists with swapped elements), but it might be much faster because of NumPy optimizations. Give it a try!
from itertools import combinations
from math import comb
arr = np.tile(candidate, (comb(len(candidate), 2), 1))
indices = np.array(list(combinations(range(len(candidate)), 2)))
arr[np.arange(arr.shape[0])[:, None], indices] = arr[np.arange(arr.shape[0])[:, None], np.flip(indices, axis=-1)]
Example (with candidate = [0, 1, 2, 3]):
>>> arr
array([[1, 0, 2, 3],
[2, 1, 0, 3],
[3, 1, 2, 0],
[0, 2, 1, 3],
[0, 3, 2, 1],
[0, 1, 3, 2]])
Notice that math.comb (which gives you the total number of possible lists with 2 swapped elements) is available only with python >= 3.8. Please have a look at this question to know how to replace math.comb in case you're using an older python version.

To swap only two items in any given list, I'd recommend using range with itertools.combinations. It is probably good to use a generator with the yield statement too, though if you are getting all results at once, it probably doesn't matter much.
from itertools import combinations
def swap2(l):
for pair in combinations(range(len(l)), 2):
l2 = l[:]
l2[pair[0]], l2[pair[1]] = l2[pair[1]], l2[pair[0]]
yield l2
if __name__ == "__main__":
candidate = [5, 9, 1, 8, 3, 7, 10, 6, 4, 2]
result = [l for l in swap2(candidate)]

Inconsistent shape between the condition and the input while using seaborn

I am trying to plot a heatmap with seaborn. Here is the list that I am trying to plot:
b = [5, 4, 4, 4, 13, 4, 4, 1, 9, 4, 3, 9, 1, 4, 4, 1, 7, 1, 5, 3, 7, 1, 9, 4, 3, 9, 5, 4, 2, 1, 4, 1, 9, 4, 3, 9, 4, 8, 1, 7, 1, 9, 4, 8, 1, 7, 1, 4, 8, 1, 7, 1, 4, 1, 7, 1, 4, 10, 4, 3, 4, 7, 1, 8, 5, 10, 8, 9, 4, 1, 3, 9, 4, 1, 9, 4, 3, 7, 7, 1, 1, 3, 4, 9, 5, 5, 4, 1, 1, 9, 4, 9, 4, 7, 1, 9, 4, 10, 9, 4, 4, 4, 8, 10, 3, 9, 5, 4, 4, 1, 3, 9, 4, 10, 5, 4, 1, 1, 8, 1, 7, 5, 1, 8, 8, 5, 3, 1, 8, 8, 8, 1, 3, 4, 2, 1, 2, 9, 4, 10, 1, 5, 3, 9, 5, 4, 4, 4, 1, 1, 7, 1, 8, 2, 1, 8, 5, 9, 5, 10, 9, 5, 4, 1, 10, 7, 1, 8, 5, 2, 1, 3, 4, 7, 1, 2, 1, 7, 1, 4, 4, 8, 5, 3, 7, 1, 2, 1, 10, 9, 4, 1, 2, 1, 3, 9, 4, 10, 9, 1, 9, 5, 4, 3, 9, 4, 1, 8, 5, 9, 4, 1, 1, 3, 9, 4, 9, 5, 4, 1, 1, 9, 4, 3, 4, 10, 1, 9, 4, 3, 4, 10, 7, 1, 7, 1, 9, 4, 3, 4, 4, 1, 1, 9, 5, 4, 3, 5, 4, 1, 8, 5, 7, 1, 3, 9, 4, 10, 9, 4, 9, 1, 8, 5, 3, 9, 4, 1, 3, 9, 5, 3, 9, 4, 1, 3, 4, 4, 4, 8, 8, 3, 9, 5, 4, 3, 5, 4, 10, 4, 7, 1, 5, 7, 1, 1, 3, 9, 4, 10, 4, 4, 1, 9, 4, 1, 1, 5, 4, 4, 3, 5, 4, 3, 5, 4, 3, 4, 4, 1, 1, 2, 1, 4, 3, 5, 4, 3, 4, 4, 4, 4, 4, 1, 1, 8, 8, 9, 5, 8, 4, 7, 1, 2, 4, 3, 9, 4, 10, 1, 1, 3, 4, 7, 1, 4, 1, 1, 8, 5, 3, 9, 5, 4, 10, 8, 3, 4, 4, 1, 1, 3, 9, 4, 2, 5, 5, 4, 4, 1, 1, 2, 1, 7, 3, 4, 9, 1, 4, 10, 9, 4, 9, 6, 4, 11, 5, 4, 10, 4, 4, 1, 9, 5, 4, 3, 9, 4, 3, 9, 5, 12, 4, 4, 4, 1, 1, 3, 9, 5, 4, 1, 3, 5, 4, 4, 4, 10, 1, 4, 4, 10, 4, 1, 5, 3, 5, 4, 4, 7, 1, 8, 4, 1, 2, 1, 9, 4, 3, 7, 1, 9, 5, 4, 4, 10, 9, 5, 4, 4, 3, 5, 10, 5, 4, 4, 1, 9, 4, 7, 1, 5, 3, 1, 4, 3, 4, 5, 3, 1, 5, 4, 5, 3, 4, 10, 8, 5, 3, 9, 4, 3, 4, 3, 7, 9, 1, 9, 4, 4, 3, 9, 4, 4, 4, 8, 9, 4, 3, 9, 5, 4, 4, 2, 5, 4, 1, 8, 3, 9, 4, 4, 10, 7, 1, 1, 9, 4, 3, 4, 9, 4, 1, 2, 1, 10, 1, 9, 4, 2, 1, 4, 1, 8, 5, 4, 3, 9, 4, 1, 9, 4, 3, 9, 3, 9, 4, 1, 4, 4, 1, 7, 7, 1, 2, 1, 3, 4, 2, 1, 4, 10, 1, 7, 1, 3, 7, 1, 11, 1, 3, 9, 4, 1, 9, 4, 7, 1, 1, 4, 2, 1, 9, 4, 3, 4, 1, 8, 1, 9, 4, 3, 4, 1, 8, 4, 1, 7, 7, 1, 7, 1, 4, 3, 9, 5, 4, 7, 1, 8, 9, 5, 4, 7, 1, 3, 9, 4, 3, 4, 7, 1, 1]
This is the code that I am trying to use to plot:
import numpy as np
import seaborn as sns
from matplotlib.colors import ListedColormap
data = np.asarray(b)
sns.heatmap( data,cmap=ListedColormap(['green', 'yellow', 'red']))
After running the above code, this is the error I am getting:
IndexError: Inconsistent shape between the condition and the input (got (633, 1) and (633,))
I did check some other answers but none of them answered my concerns.
I am not quite sure as to where the problem lies. Here is the result that I get when run data.shape:
(633,)
Any help will be appreciated. Thanks!

import numpy as np
import seaborn as sns
from matplotlib.colors import ListedColormap
import matplotlib.pyplot as plt
data = np.asarray(b).reshape(633,1)
sns.heatmap(data,cmap=ListedColormap(['green', 'yellow', 'red']))
plt.show()
heatmap requires 2D dataset
https://seaborn.pydata.org/generated/seaborn.heatmap.html

From the docs:
data : rectangular dataset 2D dataset that can be coerced into an
ndarray. If a Pandas DataFrame is provided, the index/column
information will be used to label the columns and rows.
You have to transform your data into a 2D dataset.
One way to do so is:
sns.heatmap(data[:, np.newaxis], cmap=ListedColormap(['green', 'yellow', 'red']))

Clustering histograms of different lengths in Python

How can I cluster a large dataset of histograms with the same # of bins (8), but of different lengths? Specifically, I'd like to cluster their density distributions. I think I can do this with kmeans or hierarchical clustering, but it seems that the lengths are an issue or my setup is causing ValueError: setting an array element with a sequence.
hist_data[:, 1]
array([
array([3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 6,
6, 6, 6, 6, 6, 6, 5, 4, 3, 3, 3, 3, 3, 3, 4, 5, 6, 6, 6, 6, 6, 6,
6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
6, 6, 6, 6, 6, 6, 6, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 5, 5, 5,
5], dtype=int64),
...,
array([6, 6, 6, 6, 6, 6, 6, 5, 5, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 4, 4, 5, 5, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,
6, 6, 6, 6, 6, 6, 6, 6, 6, 5, 5, 4, 4, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 4, 5, 5, 6, 6, 6, 6, 6, 6,
6, 6, 6, 6, 6, 6, 6, 5, 5, 4, 4, 3, 3, 3, 3, 4, 5, 6, 6, 6, 6, 6,
6, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
5, 5], dtype=int64)], dtype=object)

Does this fit the bill:
import numpy as np
from sklearn.cluster import KMeans
data = hist_data[:, 1]
data = np.array([np.bincount(datum, minlength=9) for datum in data])
km = KMeans(n_clusters = 10, init="k-means++").fit(data) # 10 clusters
print(km.cluster_centers_) # cluster centres, 10x8 array

shuffle a list and then append it to another list

I use a for loop to shuffle a list and append it to another empty list (List A).
I can see each shuffled list is different, but the List A has been appended with multiple of the last shuffled list only.
print('---------shuffle list-------------------------------------')
matr=[ ]
entry=[1, 2, 3, 4, 5, 6, 7, 8, 9]
for i in range(9):
shuffle(entry )
print(entry )
matr.append(entry)
print(matr)
'''
results below:
---------shuffle list-------------------------------------
[3, 1, 7, 5, 8, 9, 2, 6, 4]
[5, 4, 6, 8, 1, 9, 7, 2, 3]
[6, 4, 7, 5, 1, 3, 2, 9, 8]
[4, 9, 8, 1, 7, 3, 6, 5, 2]
[5, 1, 9, 2, 8, 6, 4, 7, 3]
[3, 5, 1, 4, 2, 6, 8, 9, 7]
[1, 2, 4, 6, 7, 8, 3, 9, 5]
[4, 8, 1, 6, 7, 3, 5, 9, 2]
[6, 4, 2, 1, 9, 8, 3, 5, 7]
[[6, 4, 2, 1, 9, 8, 3, 5, 7], [6, 4, 2, 1, 9, 8, 3, 5, 7], [6, 4, 2, 1, 9, 8, 3, 5, 7], [6, 4, 2, 1, 9, 8, 3, 5, 7], [6, 4, 2, 1, 9, 8, 3, 5, 7], [6, 4, 2, 1, 9, 8, 3, 5, 7], [6, 4, 2, 1, 9, 8, 3, 5, 7], [6, 4, 2, 1, 9, 8, 3, 5, 7], [6, 4, 2, 1, 9, 8, 3, 5, 7]]
'''
it should have appended each of the shuffled list rather the last shuffled list.

Their same objects, so you gotta do, shuffle is an exception where you need to do this:
matr=[]
entry=[1, 2, 3, 4, 5, 6, 7, 8, 9]
for i in range(9):
entry = entry.copy()
shuffle(entry)
print(entry)
matr.append(entry)
print(matr)
Output:
[9, 7, 6, 4, 3, 2, 8, 5, 1]
[4, 3, 2, 8, 7, 1, 5, 9, 6]
[3, 9, 7, 4, 5, 8, 2, 1, 6]
[6, 1, 9, 5, 2, 3, 4, 7, 8]
[5, 4, 7, 9, 8, 2, 6, 3, 1]
[2, 3, 5, 8, 6, 7, 9, 4, 1]
[5, 4, 9, 8, 3, 6, 1, 7, 2]
[5, 1, 2, 3, 7, 8, 6, 9, 4]
[6, 8, 9, 2, 1, 5, 3, 7, 4]
[[9, 7, 6, 4, 3, 2, 8, 5, 1], [4, 3, 2, 8, 7, 1, 5, 9, 6], [3, 9, 7, 4, 5, 8, 2, 1, 6], [6, 1, 9, 5, 2, 3, 4, 7, 8], [5, 4, 7, 9, 8, 2, 6, 3, 1], [2, 3, 5, 8, 6, 7, 9, 4, 1], [5, 4, 9, 8, 3, 6, 1, 7, 2], [5, 1, 2, 3, 7, 8, 6, 9, 4], [6, 8, 9, 2, 1, 5, 3, 7, 4]]