Create a Python class named ClusteringOperations

Code will be saved in

Q$2.$py

This class will have the following methods:

a$)(16$ points possible$)$ Create a class method named calculate$\_$silhouette$\_$scores that gets

as an argument a list of partitions $($this will be a list of lists of lists $($each first level sublist

represents a partition, and partition will have multiple lists, each representing one

datapoint$)).$ As a distance function, use the Euclidean distance.

The method will implement a modified version of the silhouette coefficient score for

each data point, using a modified version of the formulas presented in class.

The modification is for $b(i)$ function which will equal to

$ma{x}_{C^{\text{'}}in\text{C}\text{l}\text{u}\text{s}\text{t}\text{e}\text{r}\text{s},C^{\text{'}}}C\frac{{\displaystyle \underset{jin{C}^{\text{'}}}{\overset{?}{}}},i}{2|C^{\text{'}}|}jd(i,j)$

The method will return a list with scores, each score representing the silhouette score

for one datapoint. The order of the data points will be kept the same as in the input

argument.

For example if let's say our datapoints are $2$D vectors, and the input argument is given

by

$\left[\begin{array}{ccc}2,1& 3,1& ?\\ 1,1& 1,2& 2,2\\ 2,3& 3,3& ?\end{array}\right]$

In this example we have three partitions: first $,$ second

$\left[\begin{array}{cc}1& 1\\ 1& 2\\ 2& 2\end{array}\right],$ and third $\left[\begin{array}{cc}2& 3\\ 3& 3\end{array}\right].$

The first partition has two data points $2,1$ and $3,1.$

The second partition has three data points: $1,1$

$1,2,$ and $[2,2].$

The third partition has two data points $2,3$ and $3,3$

For such an input, in the result you would need to return the silhouette score for each of

these seven datapoints, in this order. The datapoints will keep the other they appear in

the input argument.

$\left[\begin{array}{cc}2& 1\\ 3& 1\\ 1& 1\\ 1& 2\\ 2& 2\\ 2& 3\\ 3& 3\end{array}\right]$

This means you will return a list with silhouette scores, and the first element will have

the silhouette score for $2,1$ datapoint, the second element will have the silhouette

score for $3,1$ datapoint, and so on$.$

Your method must work with any number of partitions, any number of datapoints, and

datapoints of any dimension.

Note: no method that calculates the silhouette score could be called. This method needs

to be fully implemented by you according to the instructions given. b$)(4$ points possible$)$ Create

a class method called invoke$\_$silhoutte that gets as an

argument a list of partitions $($same format as for method calculate$\_$silhouette$\_$scores$),$

an it calls calculate$\_$silhouette$\_$scores and gets the silhouette score for the datapoints.

It prints that on disk. After that it calculates the mean silhouette score and it returns

that value.