diff --git a/exploratory_analysis.ipynb b/exploratory_analysis.ipynb
index 45cd401c590e15eb30c3074a6055dd99ba33cfda..0fa07c2b49e73d64de3463b22b75c30eeb1118a2 100644
--- a/exploratory_analysis.ipynb
+++ b/exploratory_analysis.ipynb
@@ -36,7 +36,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "In this tutorial, we use unsupervised learning for a preliminary exploration of materials science data. More specifically, we analyze 82 octet binary materials known to crystallize in zinc blende (ZB) and rocksalst (RS) structures. Our aim is to show how to facilitate the visualization of unlabeled data and gain an understanding of the relevant inner structures inside the dataset. As a first step in our data analysis, we would like to detect whether data points can be classified into different clusters, where each cluster is aimed to group together objects that share similar features. With an explorative analysis we would like to visualize the structure and spatial displacement of the clusters, but when the feature space is higlhly multidimensional such visualization is directly not possible. Hence, we project the feature space into a two-dimensional manifold which, instead, can be visualized. To avoid losing relevant information, the embedding into a lower dimensional manifold must be performed while preserving the most informative features in the original space. Below we introduce into different clustering and embedding methods, which can be combined to obtain different visualizations of our dataset."
+ "In this tutorial, we use unsupervised learning for a preliminary exploration of materials science data. More specifically, we analyze 82 octet binary materials known to crystallize in zinc blende (ZB) and rocksalt (RS) structures. Our aim is to show how to facilitate the visualization of unlabeled data and gain an understanding of the relevant inner structures inside the dataset. As a first step in our data analysis, we would like to detect whether data points can be classified into different clusters, where each cluster is aimed to group together objects that share similar features. With an explorative analysis we would like to visualize the structure and spatial displacement of the clusters, but when the feature space is higlhly multidimensional such visualization is directly not possible. Hence, we project the feature space onto a two-dimensional manifold which, instead, can be visualized. To avoid losing relevant information, the embedding into a lower dimensional manifold must be performed while preserving the most informative features in the original space. Below we introduce into different clustering and embedding methods, which can be combined to obtain different visualizations of our dataset."
]
},
{
@@ -50,10 +50,10 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Cluster analysis is performed to group together data points that are more similar to each other in comparison with points belonging to other clusters. Clustering can be achieved by means of many different algorithms, each with proper characteristics and input parameters. The choice of the clustering algorithms to be used depends on the specific data set analyzed, and, once an optimal algorithm has been chosen, it is often necessary to iteratively modify the input parameters until results achieve the desired resolution. We focus on four different algorithms as described below.\n",
- "- ___k_-means__ partitions the data set into _k_ clusters, where each data point belongs to the cluster with the nearest mean. This partition ultimately minimizes the within-cluster variance to find the most compact partitioning of the data set. _K_-means uses an iterative refinement technique that is fast and scalable, but if falls in local minima. Thus, the algorithm is iterated multiple times with different initial conditions and the best outcome is finally chosen. Drawbacks of this algorithm are that the number of clusters _k_ is an input parameter which must be known in advance and clusters are convex shaped.\n",
- "- __Hierarchical clustering__ builds a hierarchy of clusters with a bottom-up (__agglomerative__) or top-down (__divisive__) approach. In a bottom-up approach, that we deploy below, starting with all data points placed in its own cluster, different pairs of clusters are iteratively merged together where the decision of the clusters to be merged is determined in a greedy manner. This is iterated until all points are grouped within one cluster, and the resulting hierarchy of clusters is presentend in a dendogram. If a distance thereshold is given, merging of clusters when outside this distance, this stops the algorithm when no more mergings are possible. The algorithm then returns a certain number of clusters as a function of the threshold distance . An advantage of this algorithm is that the construction of dendroids allows for a visual inspection of the clustering, but hierarchical clustering is considerably slower than the other algorithms discussed above and not well suited for big data.\n",
- "- Density-based spatial clustering of applications with noise (__DBSCAN__) is a algorithm that, without knowing the exact number of clusters, groups points that are close to each other leaving outliers marked as noise and not defined in any cluster. In this algorithm a neighborood distance _$\\epsilon$_ and a number of points _min-samples_ are used to determine whether a point belongs to a cluster: in case the point has a number _min-samples_ of other points within the distance _$\\epsilon$_ is marked as core point and belongs to a cluster; otherwise, the point is marked as noise. This algorithm is fast and clusters can assume any shape, but the choice of the distance _$\\epsilon$_ migth be non trivial.\n",
+ "Cluster analysis is performed to group together data points that are more similar to each other in comparison with points belonging in other clusters. Clustering can be achieved by means of many different algorithms, each with proper characteristics and input parameters. The choice of the clustering algorithms to be used depends on the specific dataset analyzed, and, once an optimal algorithm has been chosen, it is often necessary to iteratively modify the input parameters until results achieve the desired resolution. We focus on four different algorithms as described below.\n",
+ "- ___k_-means__ partitions the data set into _k_ clusters, where each datapoint belongs in the cluster with the nearest mean. This partition ultimately minimizes the within-cluster variance to find the most compact partitioning of the data set. _k_-means uses an iterative refinement technique that is fast and scalable, but if falls in local minima. Thus, the algorithm is iterated multiple times with different initial conditions and the best outcome is finally chosen. Drawbacks of this algorithm are that the number of clusters _k_ is an input parameter which must be known in advance and clusters are convex shaped.\n",
+ "- __Hierarchical clustering__ builds a hierarchy of clusters with a bottom-up (__agglomerative__) or top-down (__divisive__) approach. In a bottom-up approach, that we deploy below, starting with all datapoints placed in its own cluster, different pairs of clusters are iteratively merged together where the decision of the clusters to be merged is determined in a greedy manner. This is iterated until all points are grouped within one cluster, and the resulting hierarchy of clusters is presentend in a dendrogram. If a distance threshold is given, clusters are not merged if they are more distant than the threshold value, and this stops the algorithm when no more mergings are possible. The algorithm then returns a certain number of clusters as a function of the threshold distance. An advantage of this algorithm is that the construction of dendroids allows for a visual inspection of the clustering, but hierarchical clustering is a rather slow algorithm and not well suited for big data.\n",
+ "- Density-based spatial clustering of applications with noise (__DBSCAN__) is an algorithm that, without knowing the exact number of clusters, groups points that are close to each other leaving outliers marked as noise and not defined in any clusters. In this algorithm a neighborood distance _$\\epsilon$_ and a number of points _min-samples_ are used to determine whether a point belongs to a cluster: in case the point has a number _min-samples_ of other points within the distance _$\\epsilon$_ is marked as core point and belongs to a cluster; otherwise, the point is marked as noise. This algorithm is fast and clusters can assume any shapes, but the choice of the distance _$\\epsilon$_ migth be non trivial.\n",
"- The fast search and find of density peaks (__DenPeak__) algorithm is a density-based algorithm that is able to automatically locate non-spherical clusters. Density peaks are assumed to be sourrounded by lower density regions. Based on the position of the highest density peak, the peaks can be visualized on a graph that shows their sourrounding density and the distance from the first peak. It is then possible to choose the peaks to include from this plot, where each peak represents a different cluster."
]
},
@@ -68,7 +68,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Visualization of a dataset is not possible when it is defined in a highly multidimensional space, but a visual analysis can help to detect inner structures in the dataset. Hence, in order to make such visualization possible, we reduce the dimensionality of the system with methodologies specifically developed to avoid losing critical information during the embedding into a lower dimensionality space. In this tutorial, we use three different embedding methods that are summarize below.\n",
+ "Visualization of a dataset is not possible when it is defined in a highly multidimensional space, but a visual analysis can help to detect inner structures in the dataset. Hence, in order to make such visualization possible, we reduce the dimensionality of the system with methodologies specifically developed to avoid losing critical information during the embedding into a lower dimensionality space. In this tutorial, we use three different embedding methods that are summarized below.\n",
"- Principal component analysis (__PCA__) is a linear projection method that seeks for an orthogonal transformation of the dataset so as to render the variables of the dataset uncorrelated. The dimensionality reduction is then performed onto the features with highest variance to preserve as much information as possible. This is a deterministic but linear method, that fails to catch non linear correlations.\n",
"- Multi-dimensional scaling (__MDS__) constructs a pairwise distance matrix in the original space, and seeks a low-dimensional representation that preserves the original distances as much as possible. This method tends to preserve local structures better than global structures and scales badly with the number of data points. \n",
"- T-distributed Stochastic Neighbor Embedding (__t-SNE__) is a non-linear dimensionality reduction method that converts similarities between data points to joint probabilities and minimizes the Kullback-Leibler divergence between the joint probabilities of the embedding and the original space. The cost function is not convex and results depend on the inizialization. Non linear effects in this method might occasionally produce misleading results, therefore several iterations of the method are recommended.\n"
@@ -90,8 +90,13 @@
},
{
"cell_type": "code",
- "execution_count": null,
- "metadata": {},
+ "execution_count": 88,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2021-01-01T16:07:03.608283Z",
+ "start_time": "2021-01-01T16:07:03.598933Z"
+ }
+ },
"outputs": [],
"source": [
"from ase.io import read\n",
@@ -105,18 +110,26 @@
"from sklearn.svm import SVC\n",
"from sklearn.model_selection import train_test_split\n",
"import plotly.express as px\n",
+ "import plotly.graph_objects as go\n",
"import ipywidgets as widgets\n",
- "from IPython.display import display\n",
+ "from IPython.display import display, clear_output\n",
"from pydpc import Cluster as DPCClustering\n",
"import matplotlib.pyplot as plt"
]
},
{
"cell_type": "code",
- "execution_count": null,
- "metadata": {},
+ "execution_count": 89,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2021-01-01T16:07:04.219755Z",
+ "start_time": "2021-01-01T16:07:04.215903Z"
+ }
+ },
"outputs": [],
"source": [
+ "import warnings\n",
+ "warnings.filterwarnings(\"ignore\", category=DeprecationWarning) \n",
"pd.options.mode.chained_assignment = None"
]
},
@@ -125,7 +138,7 @@
"metadata": {},
"source": [
"# Get the data\n",
- "We load the data and place it into a Panda's dataframe. Data has been downloaded from the NOMAD archive and the NOMAD atomic data collection. It consists of RS-ZB energy differences (in eV/atom) of the 82 octet binary compounds, structure objects containing the atomic positions of the materials and properties of the atomic constituents. The following atomic features are included:\n",
+ "We load the data and place it into a Panda's dataframe. Data has been downloaded from the NOMAD Archive and the NOMAD atomic data collection. It consists of RS-ZB energy differences (in eV/atom) of the 82 octet binary compounds, structure objects containing the atomic positions of the materials and properties of the atomic constituents. The following atomic features are included:\n",
"\n",
"- Z: atomic number\n",
"- period: period in the periodic table\n",
@@ -138,8 +151,12 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 25,
"metadata": {
+ "ExecuteTime": {
+ "end_time": "2021-01-01T15:08:43.334067Z",
+ "start_time": "2021-01-01T15:08:43.240012Z"
+ },
"scrolled": true
},
"outputs": [],
@@ -189,13 +206,18 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "A 'Clustering' class is defined that includes all clustering algorithms that are covered during the tutorial. Before creating an instance of this class, a dataframe variable 'df' must have been defined. The clustering functions in the class, assign labels to the entries in the dataframe according to the results of the clustering."
+ "A 'Clustering' class is defined that includes all clustering algorithms that are covered during the tutorial. Before creating an instance of this class, a dataframe variable 'df' must have been defined. The clustering functions in the class assign labels to the entries in the dataframe according to the outcome of the clustering."
]
},
{
"cell_type": "code",
- "execution_count": null,
- "metadata": {},
+ "execution_count": 8,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2021-01-01T14:50:23.468443Z",
+ "start_time": "2021-01-01T14:50:23.458779Z"
+ }
+ },
"outputs": [],
"source": [
"class Clustering:\n",
@@ -248,73 +270,125 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "The embedding algorithms are handled with a graphical interface that is generated using Jupyter Widgets, that allows to generate a plot with the desiered embedding algorithm by pushing a bottom. Before plotting data with any embedding algorithm, a dataframe 'df' must have been defined and cluster labels assigned to each data point."
+ "The embedding algorithms are handled with a graphical interface that is generated using Jupyter Widgets, that allows to generate a plot with the desiered embedding algorithm by pushing a button. Before plotting data with any of the embedding algorithms, a dataframe 'df' must have been defined, and cluster labels assigned to each data point."
]
},
{
"cell_type": "code",
- "execution_count": null,
- "metadata": {},
+ "execution_count": 320,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2021-01-01T20:10:15.901128Z",
+ "start_time": "2021-01-01T20:10:15.888977Z"
+ }
+ },
"outputs": [],
"source": [
- "btn_PCA = widgets.Button(description='PCA')\n",
- "btn_MDS = widgets.Button(description='MDS')\n",
- "btn_tSNE = widgets.Button(description='t-SNE')\n",
- "btn_kmeans = widgets.Button(description='k-means')\n",
- "btn_hierarchical = widgets.Button(description='hierarchical')\n",
- "btn_dbscan = widgets.Button(description='DBSCAN')\n",
- "btn_plot = widgets.Button (description='plot')\n",
+ "def show_embedding ():\n",
"\n",
+ " btn_PCA = widgets.Button(description='PCA')\n",
+ " btn_MDS = widgets.Button(description='MDS')\n",
+ " btn_tSNE = widgets.Button(description='t-SNE')\n",
+ " btn_kmeans = widgets.Button(description='k-means')\n",
+ " btn_hierarchical = widgets.Button(description='hierarchical')\n",
+ " btn_dbscan = widgets.Button(description='DBSCAN')\n",
+ " btn_plot = widgets.Button (description='plot')\n",
"\n",
- "def btn_eventhandler_embedding (obj):\n",
+ " def btn_eventhandler_embedding (obj):\n",
"\n",
- " method = str (obj.description)\n",
- " \n",
- " try:\n",
- " df \n",
- " except NameError:\n",
- " print(\"Please define a dataframe 'df'\")\n",
- " return\n",
- " try:\n",
- " df['clustering'][0]\n",
- " except KeyError:\n",
- " print(\"Please assign labels with a clustering algorithm\")\n",
- " return\n",
- " try:\n",
- " hover_features\n",
- " except NameError:\n",
- " print(\"Please create a list 'hover_features' containing all hover features\")\n",
- " return\n",
- " \n",
- " if (method == 'PCA'):\n",
- " transformed_data = PCA(n_components=2).fit_transform(df[features])\n",
- " df['x_emb']=transformed_data[:,0]\n",
- " df['y_emb']=transformed_data[:,1]\n",
- " df['embedding'] = 'PCA'\n",
- " elif (method == 'MDS'):\n",
- " transformed_data = MDS (n_components=2).fit_transform(df[features])\n",
- " df['x_emb']=transformed_data[:,0]\n",
- " df['y_emb']=transformed_data[:,1]\n",
- " df['embedding'] = 'MDS'\n",
- " elif (method == 't-SNE'):\n",
- " transformed_data = TSNE (n_components=2).fit_transform(df[features])\n",
- " df['x_emb']=transformed_data[:,0]\n",
- " df['y_emb']=transformed_data[:,1]\n",
- " df['embedding'] = 't-SNE'\n",
- " plot_embedding()\n",
+ " method = str (obj.description)\n",
"\n",
- "def plot_embedding():\n",
- " print (\"Clustering algorithm used: \",df['clustering'][0], \"\\t Embedding method used: \", df['embedding'][0]) \n",
- "# df[\"labels\"]=df[\"labels\"].astype(str)\n",
- " display(px.scatter(df,x='x_emb',y='y_emb',color=df['labels'].astype(str),hover_data=df[hover_features], hover_name=df.index ))\n",
- " \n",
- " \n",
- "btn_PCA.on_click(btn_eventhandler_embedding)\n",
- "btn_MDS.on_click(btn_eventhandler_embedding)\n",
- "btn_tSNE.on_click(btn_eventhandler_embedding)\n",
+ " try:\n",
+ " df \n",
+ " except NameError:\n",
+ " print(\"Please define a dataframe 'df'\")\n",
+ " return\n",
+ " try:\n",
+ " df['clustering'][0]\n",
+ " except KeyError:\n",
+ " print(\"Please assign labels with a clustering algorithm\")\n",
+ " return\n",
+ " try:\n",
+ " hover_features\n",
+ " except NameError:\n",
+ " print(\"Please create a list 'hover_features' containing all hover features\")\n",
+ " return\n",
"\n",
+ " if (method == 'PCA'):\n",
+ " transformed_data = PCA(n_components=2).fit_transform(df[features])\n",
+ " df['x_emb']=transformed_data[:,0]\n",
+ " df['y_emb']=transformed_data[:,1]\n",
+ " df['embedding'] = 'PCA'\n",
+ " elif (method == 'MDS'):\n",
+ " transformed_data = MDS (n_components=2).fit_transform(df[features])\n",
+ " df['x_emb']=transformed_data[:,0]\n",
+ " df['y_emb']=transformed_data[:,1]\n",
+ " df['embedding'] = 'MDS'\n",
+ " elif (method == 't-SNE'):\n",
+ " transformed_data = TSNE (n_components=2).fit_transform(df[features])\n",
+ " df['x_emb']=transformed_data[:,0]\n",
+ " df['y_emb']=transformed_data[:,1]\n",
+ " df['embedding'] = 't-SNE'\n",
+ " plot_embedding()\n",
"\n",
- "box = widgets.HBox ([btn_PCA,btn_MDS,btn_tSNE])"
+ " def plot_embedding():\n",
+ " with fig.batch_update():\n",
+ " fig['data'][0]['x']=df['x_emb']\n",
+ " fig['data'][0]['y']=df['y_emb']\n",
+ " fig['data'][0]['customdata']=np.expand_dims(df['min_struc_type'].to_numpy(),axis=1)\n",
+ " fig['data'][0]['hovertemplate']=r\"<b>%{text}</b><br><br> Low energy structure: %{customdata[0]}<br>\"\n",
+ " fig['data'][0]['marker'].color=df['labels'].to_numpy()\n",
+ " fig['data'][0]['marker'].colorscale=tuple([tuple([0,'#14213d']),tuple([1,'#fca311'])])\n",
+ " fig['data'][0]['text']=df.index\n",
+ " fig.update_layout(plot_bgcolor='rgba(229,236,246, 0.5)',\n",
+ " xaxis=dict(visible=True),\n",
+ " yaxis=dict(visible=True))\n",
+ " label.value = \"Clustering algorithm used: \" + str(df['clustering'][0]) + \"\\t Embedding method used: \" + str(df['embedding'][0]) \n",
+ "\n",
+ " btn_PCA.on_click(btn_eventhandler_embedding)\n",
+ " btn_MDS.on_click(btn_eventhandler_embedding)\n",
+ " btn_tSNE.on_click(btn_eventhandler_embedding)\n",
+ " label = widgets.Label(value='Select a dimension reduction method to visualize the 2-dimensional embedding')\n",
+ " fig = go.FigureWidget()\n",
+ " fig.add_trace(go.Scatter(\n",
+ " name='embedding',\n",
+ " mode='markers',\n",
+ " ))\n",
+ " fig.update_layout(plot_bgcolor='rgba(229,236,246, 0.5)',\n",
+ " xaxis=dict(visible=False, title='x_emb'),\n",
+ " yaxis=dict(visible=False, title='y_emb'))\n",
+ "\n",
+ " return widgets.VBox([widgets.HBox ([btn_PCA,btn_MDS,btn_tSNE]),label, fig])"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 322,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2021-01-01T20:11:05.452861Z",
+ "start_time": "2021-01-01T20:11:05.304006Z"
+ },
+ "scrolled": false
+ },
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "fae6d0da3c25423791f763044233393e",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "VBox(children=(HBox(children=(Button(description='PCA', style=ButtonStyle()), Button(description='MDS', style=…"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "show_embedding()"
]
},
{
@@ -326,8 +400,13 @@
},
{
"cell_type": "code",
- "execution_count": null,
- "metadata": {},
+ "execution_count": 35,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2021-01-01T15:13:02.811407Z",
+ "start_time": "2021-01-01T15:13:02.806201Z"
+ }
+ },
"outputs": [],
"source": [
"features = []\n",
@@ -353,13 +432,17 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Feature standardization if the operation of rescaling data so as to be shaped as a Gaussian with zero mean and unit variance, and it is a common requirement for machine learning algorithms. In fact, estimators can be biased towards dimensions presenting higher absolute values, or outliers can undermine the learning capabilites of the algorithm. Hence, we standardize our dataset by subtracting the mean value and dividing it by the standard deviation for each variable."
+ "Feature standardization is the operation of rescaling data so as to be shaped as a Gaussian with zero mean and unit variance, and it is a common requirement for machine learning algorithms. In fact, estimators can be biased towards dimensions presenting higher absolute values, or outliers can undermine the learning capabilites of the algorithm. Hence, we standardize our dataset by subtracting the mean value and dividing it by the standard deviation for each variable."
]
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 36,
"metadata": {
+ "ExecuteTime": {
+ "end_time": "2021-01-01T15:13:03.146889Z",
+ "start_time": "2021-01-01T15:13:03.133137Z"
+ },
"scrolled": true
},
"outputs": [],
@@ -376,13 +459,30 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 37,
"metadata": {
+ "ExecuteTime": {
+ "end_time": "2021-01-01T15:13:05.302852Z",
+ "start_time": "2021-01-01T15:13:03.661340Z"
+ },
"scrolled": true
},
- "outputs": [],
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 1440x1080 with 16 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
"source": [
- "hist = df[features].hist( bins=10, figsize = (20,15))"
+ "hist = df[features].hist( bins=10, figsize = (20,15));"
]
},
{
@@ -397,7 +497,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "K-means requires the knowledge of the number of clusters and clustering depends on the initial conditions, hence the algorithm is iterated, up to _max\\_iter_ times, with different initial conditions until convergence. As we know that our octet binary materials crystallize in the RS and ZB structures, a natural distinction in this dataset is between materials with the most stable conformationzin in the RS vs ZB structure. Hence we seek for two clusters, aiming to find clusters of materials with the same most stable structure. "
+ "$k$-means requires the knowledge of the number of clusters and clustering depends on the initial condition. Therefore the algorithm is iterated, up to _max\\_iter_ times, with different initial conditions until convergence. As we know that our octet binary materials crystallize in the RS and ZB structures, a natural distinction in this dataset is between materials with the most stable conformation in the RS vs ZB structure. Hence we seek for two clusters, aiming to find clusters of materials with the same most stable structure. "
]
},
{
@@ -409,8 +509,12 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 94,
"metadata": {
+ "ExecuteTime": {
+ "end_time": "2021-01-01T16:08:09.067069Z",
+ "start_time": "2021-01-01T16:08:09.040255Z"
+ },
"scrolled": true
},
"outputs": [],
@@ -422,9 +526,32 @@
},
{
"cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
+ "execution_count": 95,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2021-01-01T16:08:09.336832Z",
+ "start_time": "2021-01-01T16:08:09.331988Z"
+ }
+ },
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "AgBr 0\n",
+ "AgCl 1\n",
+ "AgF 1\n",
+ "AgI 0\n",
+ "AlAs 0\n",
+ "AlN 1\n",
+ "AlP 0\n",
+ "AlSb 0\n",
+ "AsGa 0\n",
+ "AsB 0\n",
+ "Name: labels, dtype: int32\n"
+ ]
+ }
+ ],
"source": [
"print(df['labels'][:10])"
]
@@ -440,25 +567,132 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "Clicking any of the bottons below will display the dataset embedding according to the label placed on the botton. Different clusters are visualized with different colors, and by hovering over points it is possible to see the material they represent and some defined features. In this case we are interested to see which is the lowest energy structure of the materials, then we select only the 'min_struc_type' as hovering feature. Please note that any other feature can be added to the 'hover_features' list."
+ "Clicking any of the buttons below will display the dataset embedding according to the label placed on the button. Different clusters are visualized with different colors, and by hovering over points it is possible to see the material they represent and some defined features. In this case we are interested to see which is the lowest energy structure of the materials, then we select only the 'min_struc_type' as hovering feature. Please note that any other feature can be added to the 'hover_features' list."
]
},
{
"cell_type": "code",
- "execution_count": null,
- "metadata": {},
+ "execution_count": 101,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2021-01-01T16:10:25.790100Z",
+ "start_time": "2021-01-01T16:10:25.732129Z"
+ }
+ },
"outputs": [],
"source": [
- "hover_features = ['min_struc_type']"
+ "btn_PCA = widgets.Button(description='PCA')\n",
+ "btn_MDS = widgets.Button(description='MDS')\n",
+ "btn_tSNE = widgets.Button(description='t-SNE')\n",
+ "btn_kmeans = widgets.Button(description='k-means')\n",
+ "btn_hierarchical = widgets.Button(description='hierarchical')\n",
+ "btn_dbscan = widgets.Button(description='DBSCAN')\n",
+ "btn_plot = widgets.Button (description='plot')\n",
+ "\n",
+ "\n",
+ "def btn_eventhandler_embedding (obj):\n",
+ "\n",
+ " method = str (obj.description)\n",
+ " \n",
+ " try:\n",
+ " df \n",
+ " except NameError:\n",
+ " print(\"Please define a dataframe 'df'\")\n",
+ " return\n",
+ " try:\n",
+ " df['clustering'][0]\n",
+ " except KeyError:\n",
+ " print(\"Please assign labels with a clustering algorithm\")\n",
+ " return\n",
+ " try:\n",
+ " hover_features\n",
+ " except NameError:\n",
+ " print(\"Please create a list 'hover_features' containing all hover features\")\n",
+ " return\n",
+ " \n",
+ " if (method == 'PCA'):\n",
+ " transformed_data = PCA(n_components=2).fit_transform(df[features])\n",
+ " df['x_emb']=transformed_data[:,0]\n",
+ " df['y_emb']=transformed_data[:,1]\n",
+ " df['embedding'] = 'PCA'\n",
+ " elif (method == 'MDS'):\n",
+ " transformed_data = MDS (n_components=2).fit_transform(df[features])\n",
+ " df['x_emb']=transformed_data[:,0]\n",
+ " df['y_emb']=transformed_data[:,1]\n",
+ " df['embedding'] = 'MDS'\n",
+ " elif (method == 't-SNE'):\n",
+ " transformed_data = TSNE (n_components=2).fit_transform(df[features])\n",
+ " df['x_emb']=transformed_data[:,0]\n",
+ " df['y_emb']=transformed_data[:,1]\n",
+ " df['embedding'] = 't-SNE'\n",
+ " plot_embedding()\n",
+ "\n",
+ "def plot_embedding():\n",
+ " clear_output() \n",
+ "\n",
+ " fig = go.FigureWidget()\n",
+ "\n",
+ " fig.add_trace(go.Scatter(x=df['x_emb'],y=df['y_emb'],\n",
+ " mode='markers',\n",
+ " marker=dict(color=df['labels']),\n",
+ " customdata=np.expand_dims(df['min_struc_type'].to_numpy(),axis=1),\n",
+ " text=df.index,\n",
+ " hovertemplate=\n",
+ " r\"<b>%{text}</b><br><br>\" +\n",
+ " \"x axis: %{x:,.2f}<br>\" +\n",
+ " \"y axis: %{y:,.2f}<br>\" +\n",
+ " \"Low energy structure: %{customdata[0]}<br>\"\n",
+ " ))\n",
+ " print (\"Clustering algorithm used: \",df['clustering'][0], \"\\t Embedding method used: \", df['embedding'][0]) \n",
+ "# df[\"labels\"]=df[\"labels\"].astype(str)\n",
+ "# display(px.scatter(df,x='x_emb',y='y_emb',color=df['labels'].astype(str),hover_data=df[hover_features], hover_name=df.index ))\n",
+ "# with output:\n",
+ " display(fig)\n",
+ " \n",
+ "btn_PCA.on_click(btn_eventhandler_embedding)\n",
+ "btn_MDS.on_click(btn_eventhandler_embedding)\n",
+ "btn_tSNE.on_click(btn_eventhandler_embedding)\n",
+ "\n",
+ "\n",
+ "box = widgets.HBox ([btn_PCA,btn_MDS,btn_tSNE])"
]
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 104,
"metadata": {
+ "ExecuteTime": {
+ "end_time": "2021-01-01T16:10:36.562307Z",
+ "start_time": "2021-01-01T16:10:36.553397Z"
+ },
"scrolled": false
},
- "outputs": [],
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Clustering algorithm used: k-means \t Embedding method used: t-SNE\n"
+ ]
+ },
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "372ac81158154de79dae475e8db9b9d6",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "FigureWidget({\n",
+ " 'data': [{'customdata': array([['RS'],\n",
+ " ['RS'],\n",
+ " …"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
"source": [
"display(box)"
]
@@ -481,8 +715,13 @@
},
{
"cell_type": "code",
- "execution_count": null,
- "metadata": {},
+ "execution_count": 14,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-12-18T18:43:38.603954Z",
+ "start_time": "2020-12-18T18:43:38.597727Z"
+ }
+ },
"outputs": [],
"source": [
"def composition_RS_ZB (df):\n",
@@ -503,11 +742,69 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 15,
"metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-12-18T18:43:39.273928Z",
+ "start_time": "2020-12-18T18:43:39.238298Z"
+ },
"scrolled": true
},
- "outputs": [],
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "<div>\n",
+ "<style scoped>\n",
+ " .dataframe tbody tr th:only-of-type {\n",
+ " vertical-align: middle;\n",
+ " }\n",
+ "\n",
+ " .dataframe tbody tr th {\n",
+ " vertical-align: top;\n",
+ " }\n",
+ "\n",
+ " .dataframe thead th {\n",
+ " text-align: right;\n",
+ " }\n",
+ "</style>\n",
+ "<table border=\"1\" class=\"dataframe\">\n",
+ " <thead>\n",
+ " <tr style=\"text-align: right;\">\n",
+ " <th></th>\n",
+ " <th>RS</th>\n",
+ " <th>ZB</th>\n",
+ " <th>Materials in cluster</th>\n",
+ " </tr>\n",
+ " </thead>\n",
+ " <tbody>\n",
+ " <tr>\n",
+ " <th>0</th>\n",
+ " <td>85</td>\n",
+ " <td>15</td>\n",
+ " <td>40</td>\n",
+ " </tr>\n",
+ " <tr>\n",
+ " <th>1</th>\n",
+ " <td>16</td>\n",
+ " <td>83</td>\n",
+ " <td>42</td>\n",
+ " </tr>\n",
+ " </tbody>\n",
+ "</table>\n",
+ "</div>"
+ ],
+ "text/plain": [
+ " RS ZB Materials in cluster\n",
+ "0 85 15 40\n",
+ "1 16 83 42"
+ ]
+ },
+ "execution_count": 15,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
"source": [
"composition_RS_ZB(df)"
]
@@ -516,7 +813,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "We can see that K-means finds two distinct clusters, and in one of these clusters there are more 'RS' stable structures while in the other there are more 'ZB' stable structures. This is a hint that in the space described by the atomic features, materials with the same most stable structure are close to each other. On the other hand, we know that K-means is only able to detect spherically shaped clusters, therefore delimiting clusters containing only one specific stable structure is difficult under this assumption."
+ "We can see that $k$-means finds two distinct clusters, and in one of these clusters there are more 'RS' stable structures while in the other there are more 'ZB' stable structures. This is a hint that in the space described by the atomic features, materials with the same most stable structure are close to each other. On the other hand, we know that $k$-means is only able to detect spherically shaped clusters, and the delimitation of clusters containing only one specific stable structure can be difficult under this assumption."
]
},
{
@@ -536,8 +833,13 @@
},
{
"cell_type": "code",
- "execution_count": null,
- "metadata": {},
+ "execution_count": 16,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-12-18T18:50:54.589458Z",
+ "start_time": "2020-12-18T18:50:54.569294Z"
+ }
+ },
"outputs": [],
"source": [
"eps = 3\n",
@@ -547,20 +849,98 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 17,
"metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-12-18T18:50:55.527429Z",
+ "start_time": "2020-12-18T18:50:55.518975Z"
+ },
"scrolled": true
},
- "outputs": [],
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "1ac9898689124574aef1ccc5775edf6f",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HBox(children=(Button(description='PCA', style=ButtonStyle()), Button(description='MDS', style=ButtonStyle()),…"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
"source": [
"display(box)"
]
},
{
"cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
+ "execution_count": 18,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-12-18T18:50:57.413977Z",
+ "start_time": "2020-12-18T18:50:57.382729Z"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "<div>\n",
+ "<style scoped>\n",
+ " .dataframe tbody tr th:only-of-type {\n",
+ " vertical-align: middle;\n",
+ " }\n",
+ "\n",
+ " .dataframe tbody tr th {\n",
+ " vertical-align: top;\n",
+ " }\n",
+ "\n",
+ " .dataframe thead th {\n",
+ " text-align: right;\n",
+ " }\n",
+ "</style>\n",
+ "<table border=\"1\" class=\"dataframe\">\n",
+ " <thead>\n",
+ " <tr style=\"text-align: right;\">\n",
+ " <th></th>\n",
+ " <th>RS</th>\n",
+ " <th>ZB</th>\n",
+ " <th>Materials in cluster</th>\n",
+ " </tr>\n",
+ " </thead>\n",
+ " <tbody>\n",
+ " <tr>\n",
+ " <th>0</th>\n",
+ " <td>0</td>\n",
+ " <td>100</td>\n",
+ " <td>17</td>\n",
+ " </tr>\n",
+ " <tr>\n",
+ " <th>1</th>\n",
+ " <td>70</td>\n",
+ " <td>30</td>\n",
+ " <td>30</td>\n",
+ " </tr>\n",
+ " </tbody>\n",
+ "</table>\n",
+ "</div>"
+ ],
+ "text/plain": [
+ " RS ZB Materials in cluster\n",
+ "0 0 100 17\n",
+ "1 70 30 30"
+ ]
+ },
+ "execution_count": 18,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
"source": [
"composition_RS_ZB(df)"
]
@@ -569,7 +949,7 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "We can see that the algorithm found two different clusters, and we notice that each cluster is more representative of the RS vs ZB stable structure compared to K-means. However, this happens at the cost of neglecting many points that have been classified as noise."
+ "We can see that the algorithm found two different clusters, and we notice that each cluster is more representative of the RS vs ZB stable structure compared to $k$-means. However, this happens at the cost of neglecting many points that have been classified as noise."
]
},
{
@@ -597,8 +977,12 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 19,
"metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-12-18T18:51:42.316557Z",
+ "start_time": "2020-12-18T18:51:42.305922Z"
+ },
"scrolled": true
},
"outputs": [],
@@ -609,11 +993,30 @@
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 20,
"metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-12-18T18:51:42.933612Z",
+ "start_time": "2020-12-18T18:51:42.924728Z"
+ },
"scrolled": false
},
- "outputs": [],
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "1ac9898689124574aef1ccc5775edf6f",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HBox(children=(Button(description='PCA', style=ButtonStyle()), Button(description='MDS', style=ButtonStyle()),…"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
"source": [
"display(box)"
]
@@ -629,14 +1032,44 @@
"cell_type": "markdown",
"metadata": {},
"source": [
- "One advantage of hierarchical methods is that they allow to decompose and understand the clustering process. Indeed, below we plot a dendogram that shows all agglomeration steps that from having all single objects as individual clusters group objects into a unique cluster. On the y-axys there is the distance threshold, and the number of biforcations in the dendogram for a certain value on the y-axis represents the number of clusters that are generated chossing that value as distance threshold. Hence, from the dendogram we can select the value of distance threshold that we need to have a certain number of clusters. "
+ "One advantage of hierarchical methods is that they allow to decompose and understand the clustering process. Indeed, below we plot a dendogram that shows all agglomeration steps that from having all single objects as individual clusters group objects into a unique supercluster. On the y-axys there is the distance threshold, and the number of biforcations in the dendogram for a certain value on the y-axis represents the number of clusters that are generated choosing that value as distance threshold. Hence, from the dendogram we can select the value of distance threshold that we need to have a certain number of clusters. "
]
},
{
"cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
+ "execution_count": 21,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-12-18T18:52:40.950213Z",
+ "start_time": "2020-12-18T18:52:40.723508Z"
+ }
+ },
+ "outputs": [
+ {
+ "ename": "AttributeError",
+ "evalue": "'AgglomerativeClustering' object has no attribute 'distances_'",
+ "output_type": "error",
+ "traceback": [
+ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+ "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)",
+ "\u001b[0;32m<ipython-input-21-4f7faa6e95b9>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m 27\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtitle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Hierarchical Clustering Dendrogram'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 28\u001b[0m \u001b[0;31m# plot the top three levels of the dendrogram\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 29\u001b[0;31m \u001b[0mplot_dendrogram\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmodel\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtruncate_mode\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'level'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mp\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 30\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mxlabel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Number of points in node (or index of point if no parenthesis).\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 31\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;32m<ipython-input-21-4f7faa6e95b9>\u001b[0m in \u001b[0;36mplot_dendrogram\u001b[0;34m(model, **kwargs)\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[0mcounts\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mi\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcurrent_count\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m linkage_matrix = np.column_stack([model.children_, model.distances_,\n\u001b[0m\u001b[1;32m 17\u001b[0m counts]).astype(float)\n\u001b[1;32m 18\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
+ "\u001b[0;31mAttributeError\u001b[0m: 'AgglomerativeClustering' object has no attribute 'distances_'"
+ ]
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 432x288 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
"source": [
"def plot_dendrogram(model, **kwargs):\n",
" # Create linkage matrix and then plot the dendrogram\n",
@@ -689,45 +1122,550 @@
},
{
"cell_type": "code",
- "execution_count": null,
- "metadata": {},
+ "execution_count": 22,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-12-18T18:55:01.700344Z",
+ "start_time": "2020-12-18T18:55:01.658371Z"
+ },
+ "scrolled": true
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "<div>\n",
+ "<style scoped>\n",
+ " .dataframe tbody tr th:only-of-type {\n",
+ " vertical-align: middle;\n",
+ " }\n",
+ "\n",
+ " .dataframe tbody tr th {\n",
+ " vertical-align: top;\n",
+ " }\n",
+ "\n",
+ " .dataframe thead th {\n",
+ " text-align: right;\n",
+ " }\n",
+ "</style>\n",
+ "<table border=\"1\" class=\"dataframe\">\n",
+ " <thead>\n",
+ " <tr style=\"text-align: right;\">\n",
+ " <th></th>\n",
+ " <th>energy_RS</th>\n",
+ " <th>energy_ZB</th>\n",
+ " <th>energy_diff</th>\n",
+ " <th>min_struc_type</th>\n",
+ " <th>Z(A)</th>\n",
+ " <th>Z(B)</th>\n",
+ " <th>period(A)</th>\n",
+ " <th>period(B)</th>\n",
+ " <th>IP(A)</th>\n",
+ " <th>IP(B)</th>\n",
+ " <th>...</th>\n",
+ " <th>r_s(B)</th>\n",
+ " <th>r_p(A)</th>\n",
+ " <th>r_p(B)</th>\n",
+ " <th>r_d(A)</th>\n",
+ " <th>r_d(B)</th>\n",
+ " <th>clustering</th>\n",
+ " <th>labels</th>\n",
+ " <th>x_emb</th>\n",
+ " <th>y_emb</th>\n",
+ " <th>embedding</th>\n",
+ " </tr>\n",
+ " </thead>\n",
+ " <tbody>\n",
+ " <tr>\n",
+ " <th>AgBr</th>\n",
+ " <td>-108781.333959</td>\n",
+ " <td>-108781.303925</td>\n",
+ " <td>-0.030033</td>\n",
+ " <td>RS</td>\n",
+ " <td>1.044160</td>\n",
+ " <td>0.500776</td>\n",
+ " <td>5.0</td>\n",
+ " <td>4.0</td>\n",
+ " <td>-0.682185</td>\n",
+ " <td>-0.155241</td>\n",
+ " <td>...</td>\n",
+ " <td>0.039278</td>\n",
+ " <td>-0.022042</td>\n",
+ " <td>0.109901</td>\n",
+ " <td>0.249586</td>\n",
+ " <td>-0.095787</td>\n",
+ " <td>Hierarchical</td>\n",
+ " <td>1</td>\n",
+ " <td>-39.526848</td>\n",
+ " <td>22.154827</td>\n",
+ " <td>t-SNE</td>\n",
+ " </tr>\n",
+ " <tr>\n",
+ " <th>AgCl</th>\n",
+ " <td>-79397.451083</td>\n",
+ " <td>-79397.408285</td>\n",
+ " <td>-0.042797</td>\n",
+ " <td>RS</td>\n",
+ " <td>1.044160</td>\n",
+ " <td>-0.558171</td>\n",
+ " <td>5.0</td>\n",
+ " <td>3.0</td>\n",
+ " <td>-0.682185</td>\n",
+ " <td>-0.550095</td>\n",
+ " <td>...</td>\n",
+ " <td>-0.349442</td>\n",
+ " <td>-0.022042</td>\n",
+ " <td>-0.333307</td>\n",
+ " <td>0.249586</td>\n",
+ " <td>-0.806601</td>\n",
+ " <td>Hierarchical</td>\n",
+ " <td>1</td>\n",
+ " <td>-50.796947</td>\n",
+ " <td>28.824591</td>\n",
+ " <td>t-SNE</td>\n",
+ " </tr>\n",
+ " <tr>\n",
+ " <th>AgF</th>\n",
+ " <td>-74477.428165</td>\n",
+ " <td>-74477.274407</td>\n",
+ " <td>-0.153758</td>\n",
+ " <td>RS</td>\n",
+ " <td>1.044160</td>\n",
+ " <td>-1.028814</td>\n",
+ " <td>5.0</td>\n",
+ " <td>2.0</td>\n",
+ " <td>-0.682185</td>\n",
+ " <td>-2.285188</td>\n",
+ " <td>...</td>\n",
+ " <td>-1.848794</td>\n",
+ " <td>-0.022042</td>\n",
+ " <td>-1.773734</td>\n",
+ " <td>0.249586</td>\n",
+ " <td>-1.659579</td>\n",
+ " <td>Hierarchical</td>\n",
+ " <td>2</td>\n",
+ " <td>38.285912</td>\n",
+ " <td>95.895142</td>\n",
+ " <td>t-SNE</td>\n",
+ " </tr>\n",
+ " <tr>\n",
+ " <th>AgI</th>\n",
+ " <td>-171339.208181</td>\n",
+ " <td>-171339.245107</td>\n",
+ " <td>0.036925</td>\n",
+ " <td>ZB</td>\n",
+ " <td>1.044160</td>\n",
+ " <td>1.559722</td>\n",
+ " <td>5.0</td>\n",
+ " <td>5.0</td>\n",
+ " <td>-0.682185</td>\n",
+ " <td>0.283853</td>\n",
+ " <td>...</td>\n",
+ " <td>0.872252</td>\n",
+ " <td>-0.022042</td>\n",
+ " <td>0.811648</td>\n",
+ " <td>0.249586</td>\n",
+ " <td>-0.628898</td>\n",
+ " <td>Hierarchical</td>\n",
+ " <td>1</td>\n",
+ " <td>-50.215115</td>\n",
+ " <td>13.525675</td>\n",
+ " <td>t-SNE</td>\n",
+ " </tr>\n",
+ " <tr>\n",
+ " <th>AlAs</th>\n",
+ " <td>-34200.077513</td>\n",
+ " <td>-34200.290775</td>\n",
+ " <td>0.213262</td>\n",
+ " <td>ZB</td>\n",
+ " <td>-0.901775</td>\n",
+ " <td>0.383115</td>\n",
+ " <td>3.0</td>\n",
+ " <td>4.0</td>\n",
+ " <td>0.560131</td>\n",
+ " <td>0.912996</td>\n",
+ " <td>...</td>\n",
+ " <td>0.594594</td>\n",
+ " <td>-0.753988</td>\n",
+ " <td>0.700845</td>\n",
+ " <td>-0.437955</td>\n",
+ " <td>0.437324</td>\n",
+ " <td>Hierarchical</td>\n",
+ " <td>0</td>\n",
+ " <td>-7.230611</td>\n",
+ " <td>-354.558777</td>\n",
+ " <td>t-SNE</td>\n",
+ " </tr>\n",
+ " <tr>\n",
+ " <th>...</th>\n",
+ " <td>...</td>\n",
+ " <td>...</td>\n",
+ " <td>...</td>\n",
+ " <td>...</td>\n",
+ " <td>...</td>\n",
+ " <td>...</td>\n",
+ " <td>...</td>\n",
+ " <td>...</td>\n",
+ " <td>...</td>\n",
+ " <td>...</td>\n",
+ " <td>...</td>\n",
+ " <td>...</td>\n",
+ " <td>...</td>\n",
+ " <td>...</td>\n",
+ " <td>...</td>\n",
+ " <td>...</td>\n",
+ " <td>...</td>\n",
+ " <td>...</td>\n",
+ " <td>...</td>\n",
+ " <td>...</td>\n",
+ " <td>...</td>\n",
+ " </tr>\n",
+ " <tr>\n",
+ " <th>SrTe</th>\n",
+ " <td>-137269.487147</td>\n",
+ " <td>-137269.107853</td>\n",
+ " <td>-0.379295</td>\n",
+ " <td>RS</td>\n",
+ " <td>0.529060</td>\n",
+ " <td>1.500892</td>\n",
+ " <td>5.0</td>\n",
+ " <td>5.0</td>\n",
+ " <td>0.423168</td>\n",
+ " <td>0.722286</td>\n",
+ " <td>...</td>\n",
+ " <td>1.094378</td>\n",
+ " <td>0.978781</td>\n",
+ " <td>1.070186</td>\n",
+ " <td>-0.931917</td>\n",
+ " <td>-0.237949</td>\n",
+ " <td>Hierarchical</td>\n",
+ " <td>1</td>\n",
+ " <td>-5.772508</td>\n",
+ " <td>10.822165</td>\n",
+ " <td>t-SNE</td>\n",
+ " </tr>\n",
+ " <tr>\n",
+ " <th>OZn</th>\n",
+ " <td>-25540.809205</td>\n",
+ " <td>-25540.911173</td>\n",
+ " <td>0.101968</td>\n",
+ " <td>ZB</td>\n",
+ " <td>0.071193</td>\n",
+ " <td>-1.087644</td>\n",
+ " <td>4.0</td>\n",
+ " <td>2.0</td>\n",
+ " <td>-1.815302</td>\n",
+ " <td>-1.348317</td>\n",
+ " <td>...</td>\n",
+ " <td>-1.571137</td>\n",
+ " <td>-0.514985</td>\n",
+ " <td>-1.552129</td>\n",
+ " <td>-0.231026</td>\n",
+ " <td>1.148139</td>\n",
+ " <td>Hierarchical</td>\n",
+ " <td>2</td>\n",
+ " <td>71.758156</td>\n",
+ " <td>-28.533104</td>\n",
+ " <td>t-SNE</td>\n",
+ " </tr>\n",
+ " <tr>\n",
+ " <th>SZn</th>\n",
+ " <td>-29945.889373</td>\n",
+ " <td>-29946.165186</td>\n",
+ " <td>0.275813</td>\n",
+ " <td>ZB</td>\n",
+ " <td>0.071193</td>\n",
+ " <td>-0.617001</td>\n",
+ " <td>4.0</td>\n",
+ " <td>3.0</td>\n",
+ " <td>-1.815302</td>\n",
+ " <td>0.114207</td>\n",
+ " <td>...</td>\n",
+ " <td>-0.016253</td>\n",
+ " <td>-0.514985</td>\n",
+ " <td>-0.000901</td>\n",
+ " <td>-0.231026</td>\n",
+ " <td>1.681250</td>\n",
+ " <td>Hierarchical</td>\n",
+ " <td>3</td>\n",
+ " <td>35.325409</td>\n",
+ " <td>-33.065041</td>\n",
+ " <td>t-SNE</td>\n",
+ " </tr>\n",
+ " <tr>\n",
+ " <th>SeZn</th>\n",
+ " <td>-57752.319875</td>\n",
+ " <td>-57752.583012</td>\n",
+ " <td>0.263137</td>\n",
+ " <td>ZB</td>\n",
+ " <td>0.071193</td>\n",
+ " <td>0.441945</td>\n",
+ " <td>4.0</td>\n",
+ " <td>4.0</td>\n",
+ " <td>-1.815302</td>\n",
+ " <td>0.381952</td>\n",
+ " <td>...</td>\n",
+ " <td>0.316936</td>\n",
+ " <td>-0.514985</td>\n",
+ " <td>0.368439</td>\n",
+ " <td>-0.231026</td>\n",
+ " <td>1.005977</td>\n",
+ " <td>Hierarchical</td>\n",
+ " <td>3</td>\n",
+ " <td>28.319963</td>\n",
+ " <td>-44.431747</td>\n",
+ " <td>t-SNE</td>\n",
+ " </tr>\n",
+ " <tr>\n",
+ " <th>TeZn</th>\n",
+ " <td>-118239.807676</td>\n",
+ " <td>-118240.052677</td>\n",
+ " <td>0.245001</td>\n",
+ " <td>ZB</td>\n",
+ " <td>0.071193</td>\n",
+ " <td>1.500892</td>\n",
+ " <td>4.0</td>\n",
+ " <td>5.0</td>\n",
+ " <td>-1.815302</td>\n",
+ " <td>0.722286</td>\n",
+ " <td>...</td>\n",
+ " <td>1.094378</td>\n",
+ " <td>-0.514985</td>\n",
+ " <td>1.070186</td>\n",
+ " <td>-0.231026</td>\n",
+ " <td>-0.237949</td>\n",
+ " <td>Hierarchical</td>\n",
+ " <td>3</td>\n",
+ " <td>4.945252</td>\n",
+ " <td>-34.944271</td>\n",
+ " <td>t-SNE</td>\n",
+ " </tr>\n",
+ " </tbody>\n",
+ "</table>\n",
+ "<p>82 rows × 27 columns</p>\n",
+ "</div>"
+ ],
+ "text/plain": [
+ " energy_RS energy_ZB energy_diff min_struc_type Z(A) \\\n",
+ "AgBr -108781.333959 -108781.303925 -0.030033 RS 1.044160 \n",
+ "AgCl -79397.451083 -79397.408285 -0.042797 RS 1.044160 \n",
+ "AgF -74477.428165 -74477.274407 -0.153758 RS 1.044160 \n",
+ "AgI -171339.208181 -171339.245107 0.036925 ZB 1.044160 \n",
+ "AlAs -34200.077513 -34200.290775 0.213262 ZB -0.901775 \n",
+ "... ... ... ... ... ... \n",
+ "SrTe -137269.487147 -137269.107853 -0.379295 RS 0.529060 \n",
+ "OZn -25540.809205 -25540.911173 0.101968 ZB 0.071193 \n",
+ "SZn -29945.889373 -29946.165186 0.275813 ZB 0.071193 \n",
+ "SeZn -57752.319875 -57752.583012 0.263137 ZB 0.071193 \n",
+ "TeZn -118239.807676 -118240.052677 0.245001 ZB 0.071193 \n",
+ "\n",
+ " Z(B) period(A) period(B) IP(A) IP(B) ... r_s(B) \\\n",
+ "AgBr 0.500776 5.0 4.0 -0.682185 -0.155241 ... 0.039278 \n",
+ "AgCl -0.558171 5.0 3.0 -0.682185 -0.550095 ... -0.349442 \n",
+ "AgF -1.028814 5.0 2.0 -0.682185 -2.285188 ... -1.848794 \n",
+ "AgI 1.559722 5.0 5.0 -0.682185 0.283853 ... 0.872252 \n",
+ "AlAs 0.383115 3.0 4.0 0.560131 0.912996 ... 0.594594 \n",
+ "... ... ... ... ... ... ... ... \n",
+ "SrTe 1.500892 5.0 5.0 0.423168 0.722286 ... 1.094378 \n",
+ "OZn -1.087644 4.0 2.0 -1.815302 -1.348317 ... -1.571137 \n",
+ "SZn -0.617001 4.0 3.0 -1.815302 0.114207 ... -0.016253 \n",
+ "SeZn 0.441945 4.0 4.0 -1.815302 0.381952 ... 0.316936 \n",
+ "TeZn 1.500892 4.0 5.0 -1.815302 0.722286 ... 1.094378 \n",
+ "\n",
+ " r_p(A) r_p(B) r_d(A) r_d(B) clustering labels x_emb \\\n",
+ "AgBr -0.022042 0.109901 0.249586 -0.095787 Hierarchical 1 -39.526848 \n",
+ "AgCl -0.022042 -0.333307 0.249586 -0.806601 Hierarchical 1 -50.796947 \n",
+ "AgF -0.022042 -1.773734 0.249586 -1.659579 Hierarchical 2 38.285912 \n",
+ "AgI -0.022042 0.811648 0.249586 -0.628898 Hierarchical 1 -50.215115 \n",
+ "AlAs -0.753988 0.700845 -0.437955 0.437324 Hierarchical 0 -7.230611 \n",
+ "... ... ... ... ... ... ... ... \n",
+ "SrTe 0.978781 1.070186 -0.931917 -0.237949 Hierarchical 1 -5.772508 \n",
+ "OZn -0.514985 -1.552129 -0.231026 1.148139 Hierarchical 2 71.758156 \n",
+ "SZn -0.514985 -0.000901 -0.231026 1.681250 Hierarchical 3 35.325409 \n",
+ "SeZn -0.514985 0.368439 -0.231026 1.005977 Hierarchical 3 28.319963 \n",
+ "TeZn -0.514985 1.070186 -0.231026 -0.237949 Hierarchical 3 4.945252 \n",
+ "\n",
+ " y_emb embedding \n",
+ "AgBr 22.154827 t-SNE \n",
+ "AgCl 28.824591 t-SNE \n",
+ "AgF 95.895142 t-SNE \n",
+ "AgI 13.525675 t-SNE \n",
+ "AlAs -354.558777 t-SNE \n",
+ "... ... ... \n",
+ "SrTe 10.822165 t-SNE \n",
+ "OZn -28.533104 t-SNE \n",
+ "SZn -33.065041 t-SNE \n",
+ "SeZn -44.431747 t-SNE \n",
+ "TeZn -34.944271 t-SNE \n",
+ "\n",
+ "[82 rows x 27 columns]"
+ ]
+ },
+ "execution_count": 22,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "df"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 24,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-12-18T18:55:39.726794Z",
+ "start_time": "2020-12-18T18:55:39.689441Z"
+ }
+ },
"outputs": [],
"source": [
- "Clustering().dpc()"
+ "import hdbscan"
]
},
{
- "cell_type": "markdown",
- "metadata": {},
+ "cell_type": "code",
+ "execution_count": 67,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-12-18T19:02:33.653988Z",
+ "start_time": "2020-12-18T19:02:33.633756Z"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "HDBSCAN(algorithm='best', allow_single_cluster=False, alpha=1.0,\n",
+ " approx_min_span_tree=True, cluster_selection_epsilon=0.0,\n",
+ " cluster_selection_method='eom', core_dist_n_jobs=4,\n",
+ " gen_min_span_tree=False, leaf_size=40,\n",
+ " match_reference_implementation=False, memory=Memory(location=None),\n",
+ " metric='euclidean', min_cluster_size=9, min_samples=1, p=None,\n",
+ " prediction_data=False)"
+ ]
+ },
+ "execution_count": 67,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
"source": [
- "We choose the values on the x,y-axis, and the algorithm will return the clusters that are given by the peaks that we selected. In this case we select the 3 peaks which are the closest to the top right vertex."
+ "min_cluster_size = 9\n",
+ "clusterer = hdbscan.HDBSCAN(min_cluster_size=min_cluster_size, min_samples=1)\n",
+ "clusterer.fit(df[features])"
]
},
{
"cell_type": "code",
- "execution_count": null,
- "metadata": {},
+ "execution_count": 68,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-12-18T19:02:34.026348Z",
+ "start_time": "2020-12-18T19:02:34.022206Z"
+ }
+ },
"outputs": [],
"source": [
- "Clustering().dpc(2,4.)"
+ "cluster_labels=clusterer.labels_\n",
+ "df['labels']=cluster_labels\n"
]
},
{
"cell_type": "code",
- "execution_count": null,
+ "execution_count": 69,
"metadata": {
- "scrolled": true
+ "ExecuteTime": {
+ "end_time": "2020-12-18T19:02:34.365919Z",
+ "start_time": "2020-12-18T19:02:34.356374Z"
+ },
+ "scrolled": false
},
- "outputs": [],
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "1ac9898689124574aef1ccc5775edf6f",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "HBox(children=(Button(description='PCA', style=ButtonStyle()), Button(description='MDS', style=ButtonStyle()),…"
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
"source": [
"display(box)"
]
},
{
"cell_type": "code",
- "execution_count": null,
- "metadata": {},
- "outputs": [],
+ "execution_count": 70,
+ "metadata": {
+ "ExecuteTime": {
+ "end_time": "2020-12-18T19:02:34.791129Z",
+ "start_time": "2020-12-18T19:02:34.759139Z"
+ }
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/html": [
+ "<div>\n",
+ "<style scoped>\n",
+ " .dataframe tbody tr th:only-of-type {\n",
+ " vertical-align: middle;\n",
+ " }\n",
+ "\n",
+ " .dataframe tbody tr th {\n",
+ " vertical-align: top;\n",
+ " }\n",
+ "\n",
+ " .dataframe thead th {\n",
+ " text-align: right;\n",
+ " }\n",
+ "</style>\n",
+ "<table border=\"1\" class=\"dataframe\">\n",
+ " <thead>\n",
+ " <tr style=\"text-align: right;\">\n",
+ " <th></th>\n",
+ " <th>RS</th>\n",
+ " <th>ZB</th>\n",
+ " <th>Materials in cluster</th>\n",
+ " </tr>\n",
+ " </thead>\n",
+ " <tbody>\n",
+ " <tr>\n",
+ " <th>0</th>\n",
+ " <td>78</td>\n",
+ " <td>21</td>\n",
+ " <td>41</td>\n",
+ " </tr>\n",
+ " <tr>\n",
+ " <th>1</th>\n",
+ " <td>0</td>\n",
+ " <td>100</td>\n",
+ " <td>26</td>\n",
+ " </tr>\n",
+ " </tbody>\n",
+ "</table>\n",
+ "</div>"
+ ],
+ "text/plain": [
+ " RS ZB Materials in cluster\n",
+ "0 78 21 41\n",
+ "1 0 100 26"
+ ]
+ },
+ "execution_count": 70,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
"source": [
"composition_RS_ZB(df)"
]
@@ -796,7 +1734,7 @@
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
- "version": "3.7.7"
+ "version": "3.7.9"
}
},
"nbformat": 4,