{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Properties estimators\n",
"\n",
"[](https://colab.research.google.com/github/ipqa-research/ugropy/blob/main/docs/source/tutorial/properties_estimators.ipynb)\n",
"\n",
"Some group contribution models could be used to predict properties of pure\n",
"substances.\n",
"\n",
"### Joback model\n",
"\n",
"The Joback model is a well known model to estimate properties of pure \n",
"substances. We can use it independently of the Groups class by doing:"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"try:\n",
" import google.colab\n",
" IN_COLAB = True\n",
"except:\n",
" IN_COLAB = False\n",
"\n",
"\n",
"if IN_COLAB:\n",
" %pip install ugropy"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"from ugropy import joback\n",
"\n",
"toluene = joback.get_groups(\"toluene\")"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
""
],
"text/plain": [
""
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"toluene.draw(width=400)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"41.144119209325225 bar\n",
"319.5 centimeter ** 3 / mole\n",
"598.0611700010388 kelvin\n",
"0.25208296412216535 dimensionless\n",
"195.07 kelvin\n"
]
}
],
"source": [
"print(toluene.critical_pressure)\n",
"print(toluene.critical_volume)\n",
"print(toluene.critical_temperature)\n",
"print(toluene.acentric_factor)\n",
"print(toluene.fusion_temperature)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You may notice that the attributes of the `Joback` class are numbers with \n",
"units. This is possible thanks to the `pint` library. The `pint` library\n",
"allows us to work with units in a very simple way. For example, we can\n",
"convert the value of the `critical_pressure` attribute to pascal by doing:"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"4114411.9209325225 pascal"
],
"text/latex": [
"$4114411.9209325225\\ \\mathrm{pascal}$"
],
"text/plain": [
""
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"toluene.critical_pressure.to(\"Pa\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If you want to obtain the value of the attribute without units, you can\n",
"use the `magnitude` attribute:"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"np.float64(41.144119209325225)"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"toluene.critical_pressure.magnitude"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Or combine all that we know:"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"np.float64(30860.62289092802)"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"toluene.critical_pressure.to(\"mmHg\").magnitude"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"For more information about the `pint` library, you can visit their \n",
"documentation."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On the other hand, we can use the `Joback` class to estimate\n",
"temperature-dependent properties of the molecule (also with `pint` units). In\n",
"the API documentation you can check the available methods to estimate\n",
"properties and how its done."
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.923433500943906 bar\n"
]
}
],
"source": [
"print(toluene.vapor_pressure(110 + 273.15))"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0.0004848511681835698 pascal * second\n"
]
}
],
"source": [
"print(toluene.viscosity_liquid(25 + 273.15))"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"174.140191226778 joule / kelvin / mole\n"
]
}
],
"source": [
"print(toluene.heat_capacity_liquid(50 + 273.15))"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"150.13004821343338 joule/(kelvin mole)"
],
"text/latex": [
"$150.13004821343338\\ \\frac{\\mathrm{joule}}{\\left(\\mathrm{kelvin} \\cdot \\mathrm{mole}\\right)}$"
],
"text/plain": [
""
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"toluene.heat_capacity_ideal_gas(150 + 273.15)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"You can check the full documentation and check all the properties you can \n",
"estimate by doing:"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\u001b[0;31mType:\u001b[0m JobackFragmentationResult\n",
"\u001b[0;31mString form:\u001b[0m \n",
"\u001b[0;31mFile:\u001b[0m ~/code/ugropy/ugropy/core/frag_classes/joback/joback_result.py\n",
"\u001b[0;31mDocstring:\u001b[0m \n",
"Joback group contribution properties estimator.\n",
"\n",
"The class recieves either the Joback and Reid model's :cite:p:`joback1,\n",
"joback2` groups, name or smiles of a molecule and estimates the its\n",
"properties.\n",
"\n",
"Parameters\n",
"----------\n",
"molecule : Chem.rdchem.Mol\n",
" RDKit molecule object.\n",
"subgroups : dict\n",
" Dictionary of subgroups.\n",
"subgroups_atoms_indexes : dict\n",
" Dictionary of subgroups atoms indexes.\n",
"properties_contributions : pd.DataFrame\n",
" DataFrame with Joback's properties contributions.\n",
"normal_boiling_point : float, optional\n",
" User provided experimental normal boiling point [K].\n",
"\n",
"Attributes\n",
"----------\n",
"subgroups : dict\n",
" Joback functional groups of the molecule.\n",
"experimental_boiling_temperature : pint.Quantity\n",
" User provided experimental normal boiling point [K].\n",
"critical_temperature : pint.Quantity\n",
" Joback estimated critical temperature [K].\n",
"critical_pressure : pint.Quantity\n",
" Joback estimated critical pressure [bar].\n",
"critical_volume : pint.Quantity\n",
" Joback estimated critical volume [cm³/mol].\n",
"normal_boiling_point : pint.Quantity\n",
" Joback estimated normal boiling point [K].\n",
"fusion_temperature : pint.Quantity\n",
" Joback estimated fusion temperature [K].\n",
"ig_formation_formation : pint.Quantity\n",
" Joback estimated enthalpy of formation ideal gas at 298 K [kJ/mol].\n",
"ig_gibbs_formation : pint.Quantity\n",
" Joback estimated Gibbs energy of formation ideal gas at 298 K [K].\n",
"heat_capacity_ideal_gas_params : dict\n",
" Joback estimated Reid's ideal gas heat capacity equation parameters\n",
" [J/mol/K].\n",
"fusion_enthalpy : pint.Quantity\n",
" Joback estimated fusion enthalpy [kJ/mol].\n",
"vaporization_enthalpy : pint.Quantity\n",
" Joback estimated vaporization enthalpy at the normal boiling point\n",
" [kJ/mol].\n",
"sum_na : float\n",
" Joback n_A contribution to liquid viscosity [Pa s].\n",
"sum_nb : float\n",
" Joback n_B contribution to liquid viscosity [Pa s].\n",
"molecular_weight : pint.Quantity\n",
" Molecular weight from Joback's subgroups [g/mol].\n",
"acentric_factor : pint.Quantity\n",
" Acentric factor from Lee and Kesler's equation :cite:p:`joback1`.\n",
"vapor_pressure_params : dict\n",
" Vapor pressure G and k parameters for the Riedel-Plank-Miller\n",
" equation [bar] :cite:p:`joback1`."
]
}
],
"source": [
"?toluene"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Joback model allows the user to provide the experimental normal boiling\n",
"temperature of the subtance to increase the accuracy of some properties\n",
"estimations. This value will be used instead of the Joback estimated normal\n",
"boiling temperature to calculate some properties, for example the critical\n",
"temperature."
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [],
"source": [
"toluene = joback.get_groups(\"toluene\", normal_boiling_point=(110.6 + 273.15))"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"593.8980798775972 kelvin\n"
]
}
],
"source": [
"print(toluene.critical_temperature)"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1.0132500000000007 bar\n"
]
}
],
"source": [
"print(toluene.vapor_pressure(110.6 + 273.15))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Abdulelah-Gani model\n",
"\n",
"https://github.com/PEESEgroup/Pure-Component-Property-Estimation\n",
"\n",
"The recently developed Abdulelah-Gani model is also available in `ugropy`. This\n",
"model is on an early stage of development and it is not as complete as the \n",
"original publication. Some of tertiary structures are not yet implemented and \n",
"for that, the properties that depend on them are not available. Let's see how\n",
"to use it:"
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {},
"outputs": [],
"source": [
"from ugropy import abdulelah_gani"
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {},
"outputs": [],
"source": [
"adrenaline = abdulelah_gani.get_groups(\"adrenaline\")"
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'CH3': 1, 'aCH': 3, 'aC-CH': 1, 'OH': 1, 'aC-OH': 2, 'CH2NH': 1}"
]
},
"execution_count": 52,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"adrenaline.primary.subgroups"
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'CHm(OH)CHn(NHp) (m,n,p in 0..2)': 1,\n",
" 'aC-CHn-OH (n in 1..2)': 1,\n",
" 'AROMRINGs1s2s4': 1}"
]
},
"execution_count": 53,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"adrenaline.secondary.subgroups"
]
},
{
"cell_type": "code",
"execution_count": 54,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{}"
]
},
"execution_count": 54,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"adrenaline.tertiary.subgroups"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As you can see, The Abdulelah-Gani model includes different kinds of subgropus.\n",
"The primary structures works as the other models we have discussed before. The\n",
"secondary and tertiary are additional structures that are used to increase\n",
"the accuracy of the estimations. Also, differentiates isomers. For example:"
]
},
{
"cell_type": "code",
"execution_count": 55,
"metadata": {},
"outputs": [],
"source": [
"hexa23 = abdulelah_gani.get_groups(\"2,3-dimethylhexane\")\n",
"hexa24 = abdulelah_gani.get_groups(\"2,4-dimethylhexane\")"
]
},
{
"cell_type": "code",
"execution_count": 56,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"564.8418659474339 kelvin"
],
"text/latex": [
"$564.8418659474339\\ \\mathrm{kelvin}$"
],
"text/plain": [
""
]
},
"execution_count": 56,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"hexa23.critical_temperature"
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"549.3932758799738 kelvin"
],
"text/latex": [
"$549.3932758799738\\ \\mathrm{kelvin}$"
],
"text/plain": [
""
]
},
"execution_count": 57,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"hexa24.critical_temperature"
]
},
{
"cell_type": "code",
"execution_count": 58,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'CH3': 4, 'CH2': 2, 'CH': 2}\n",
"{'CH3': 4, 'CH2': 2, 'CH': 2}\n"
]
}
],
"source": [
"print(hexa23.primary.subgroups)\n",
"print(hexa24.primary.subgroups)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'(CH3)2CH': 1, 'CH(CH3)CH(CH3)': 1}\n",
"{'(CH3)2CH': 1}\n"
]
}
],
"source": [
"print(hexa23.secondary.subgroups)\n",
"print(hexa24.secondary.subgroups)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As you can see, both molecules have the same primary structure but different\n",
"secondary structures. This is why the properties are different. On a Property \n",
"Estimator that only have primary structures like the Joback model we would get\n",
"the same properties for both molecules."
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"552.9339856842008 kelvin\n",
"552.9339856842008 kelvin\n"
]
}
],
"source": [
"print(joback.get_groups(\"2,3-dimethylhexane\").critical_temperature)\n",
"print(joback.get_groups(\"2,4-dimethylhexane\").critical_temperature)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"All the properties that can be estimated with the Abdulelah-Gani model are:"
]
},
{
"cell_type": "code",
"execution_count": 61,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"564.8418659474339 kelvin\n",
"26.35038783694938 bar\n",
"465.335 centimeter ** 3 / mole\n",
"0.35672642267081217 dimensionless\n",
"-214.82596509091175 kilojoule / mole\n",
"15.59002996305599 kilojoule / mole\n"
]
}
],
"source": [
"print(hexa23.critical_temperature)\n",
"print(hexa23.critical_pressure)\n",
"print(hexa23.critical_volume)\n",
"print(hexa23.acentric_factor)\n",
"print(hexa23.ig_formation_enthalpy)\n",
"print(hexa23.ig_formation_gibbs)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If you refer yo the original publication you will notice that the \n",
"Abdulelah-Gani model allows to estimate the properties by to methods:\n",
"\n",
"- GC-SIMPLE: Algebraic correlations\n",
"- ML: trained neural networks\n",
"\n",
"`ugropy` evaluates the properties using the GC-SIMPLE method. The ML method\n",
"is not provided in this library. To learn how evaluate the properties with the\n",
"ML method, please refer to the original publication supplementary material:\n",
"\n",
"https://github.com/PEESEgroup/Pure-Component-Property-Estimation\n",
"\n",
"However, `ugropy`helps you a little to evaluate the trained neural networks.\n",
"The fragmentation results give you the numpy array needed to evaluate the ML \n",
"model ready to use:"
]
},
{
"cell_type": "code",
"execution_count": 62,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[4, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
" 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
" 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n",
" 0, 0, 0, 0, 0, 0]])"
]
},
"execution_count": 62,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"hexa23.ml_vector"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To visualize the fragmentation results you can use the `draw` method\n",
"for each structure type:"
]
},
{
"cell_type": "code",
"execution_count": 71,
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
""
],
"text/plain": [
""
]
},
"execution_count": 71,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"hexa24.primary.draw(width=700)"
]
},
{
"cell_type": "code",
"execution_count": 72,
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
""
],
"text/plain": [
""
]
},
"execution_count": 72,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"hexa24.secondary.draw(width=700)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The example molecules doesn't have tertiary structures, let's get the solution\n",
"for a molecule that has tertiary structures:"
]
},
{
"cell_type": "code",
"execution_count": 73,
"metadata": {},
"outputs": [],
"source": [
"fluorene = abdulelah_gani.get_groups(\"9H-Fluorene\")"
]
},
{
"cell_type": "code",
"execution_count": 76,
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
""
],
"text/plain": [
""
]
},
"execution_count": 76,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fluorene.primary.draw(width=800)"
]
},
{
"cell_type": "code",
"execution_count": 77,
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
""
],
"text/plain": [
""
]
},
"execution_count": 77,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"fluorene.tertiary.draw(width=800)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Finally, getting multiple solutions. Secondary and tertiary structures can\n",
"be overlapped so they doesn't generate multiple solutions. But of course, the\n",
"primary structures will generate multiple solutions. Let's see an example:"
]
},
{
"cell_type": "code",
"execution_count": 78,
"metadata": {},
"outputs": [],
"source": [
"mol = abdulelah_gani.get_groups(\"COc1ccccc1N(=O)=O\", \"smiles\", search_multiple_solutions=True)"
]
},
{
"cell_type": "code",
"execution_count": 84,
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
""
],
"text/plain": [
""
]
},
"execution_count": 84,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"mol[0].primary.draw(width=600)"
]
},
{
"cell_type": "code",
"execution_count": 85,
"metadata": {},
"outputs": [
{
"data": {
"image/svg+xml": [
""
],
"text/plain": [
""
]
},
"execution_count": 85,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"mol[1].primary.draw(width=600)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Both solutions have the same secondary and tertiary results, but different\n",
"primary results. This is why the properties are different."
]
},
{
"cell_type": "code",
"execution_count": 88,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"750.949961574131 kelvin"
],
"text/latex": [
"$750.949961574131\\ \\mathrm{kelvin}$"
],
"text/plain": [
""
]
},
"execution_count": 88,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"mol[0].critical_temperature"
]
},
{
"cell_type": "code",
"execution_count": 89,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"784.2891401277112 kelvin"
],
"text/latex": [
"$784.2891401277112\\ \\mathrm{kelvin}$"
],
"text/plain": [
""
]
},
"execution_count": 89,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"mol[1].critical_temperature"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"What a difference!! In this case, the second solution provides a much better\n",
"estimation of critical temperature (782 K). You can check it by yourself on\n",
"the publication original dataset."
]
}
],
"metadata": {
"kernelspec": {
"display_name": "ugropy",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.10.12"
}
},
"nbformat": 4,
"nbformat_minor": 2
}