RDF formation code.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "cf4a1e08",
   "metadata": {},
   "source": [
    "# Dataframes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1e312813-7dcc-426b-ae34-d6c9ced5671e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: rdflib in c:\\users\\matna\\appdata\\local\\programs\\python\\python310\\lib\\site-packages (6.2.0)\n",
      "Requirement already satisfied: sparqlwrapper in c:\\users\\matna\\appdata\\local\\programs\\python\\python310\\lib\\site-packages (2.0.0)\n",
      "Requirement already satisfied: pydotplus in c:\\users\\matna\\appdata\\local\\programs\\python\\python310\\lib\\site-packages (2.0.2)\n",
      "Requirement already satisfied: graphviz in c:\\users\\matna\\appdata\\local\\programs\\python\\python310\\lib\\site-packages (0.20.1)\n",
      "Requirement already satisfied: setuptools in c:\\users\\matna\\appdata\\local\\programs\\python\\python310\\lib\\site-packages (from rdflib) (63.2.0)\n",
      "Requirement already satisfied: pyparsing in c:\\users\\matna\\appdata\\local\\programs\\python\\python310\\lib\\site-packages (from rdflib) (3.0.9)\n",
      "Requirement already satisfied: isodate in c:\\users\\matna\\appdata\\local\\programs\\python\\python310\\lib\\site-packages (from rdflib) (0.6.1)\n",
      "Requirement already satisfied: six in c:\\users\\matna\\appdata\\local\\programs\\python\\python310\\lib\\site-packages (from isodate->rdflib) (1.16.0)\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import re\n",
    "!pip3 install rdflib sparqlwrapper pydotplus graphviz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "7316f6bf-6d02-4af7-8708-165203a762fc",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"./model_algorithm_added.csv\") # read excel data - dataframe\n",
    "df_nms=pd.read_csv(\"./nanomaterials_final_df.csv\")\n",
    "df_coatings=pd.read_csv(\"./compounds_all_new.csv\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "7331d024",
   "metadata": {},
   "outputs": [],
   "source": [
    "df_nms['CID'] = df_nms['CID'].fillna(0).astype(int)\n",
    "df.at[46,\"algo\"] = \"Stepwise-MLR PLS\"\n",
    "df.at[46,\"algoName\"] = \"Stepwise_Multiple_Linear_Regression Partial_Least_Squares\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4646c312",
   "metadata": {},
   "source": [
    "## Namespaces"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "698cbe64-c9dc-4b26-a0be-9e989be95328",
   "metadata": {},
   "outputs": [],
   "source": [
    "from rdflib import Graph, URIRef, Literal, BNode, Namespace\n",
    "from rdflib.namespace import DC, RDFS, FOAF, DCTERMS, VOID, RDF, XSD, OWL, SKOS\n",
    "# CSVW, DC, DCAT, DCTERMS, DOAP, FOAF, ODRL2, ORG, OWL, \\\n",
    "# PROF, PROV, RDF, RDFS, SDO, SH, SKOS, SOSA, SSN, TIME, \\\n",
    "# VOID, XMLNS, XSD\n",
    "\n",
    "sbd = Namespace(\"https://www.sbd4nano.eu/rdf/#\")\n",
    "ECO = Namespace(\"https://evidenceontology.org/#\")\n",
    "kb = Namespace(\"https://h2020-sbd4nano.github.io/sbd-data-landscape/\")\n",
    "enm = Namespace(\"http://purl.enanomapper.org/onto/\")\n",
    "ncit = Namespace(\"http://purl.obolibrary.org/obo/NCIT\")\n",
    "sio = Namespace(\"http://semanticscience.org/resource/\")\n",
    "CHEBI = Namespace(\"http://purl.obolibrary.org/obo/\")\n",
    "STATO = Namespace(\"http://purl.obolibrary.org/obo/\")\n",
    "PATO = Namespace(\"http://purl.obolibrary.org/obo/\") #Phenotype And Trait Ontology\n",
    "MESH = Namespace(\"http://purl.bioontology.org/ontology/MESH/\") #Medical Subject Headings\n",
    "OBI = Namespace(\"http://purl.obolibrary.org/obo/\") #Ontology for biomedical investigations\n",
    "CL = Namespace(\"http://purl.obolibrary.org/obo/\") #Cell Ontology\n",
    "PUBCHEM = Namespace(\"https://pubchem.ncbi.nlm.nih.gov/compound/\")\n",
    "npo = Namespace(\"http://purl.bioontology.org/ontology/npo#\")\n",
    "BAO = Namespace(\"http://www.bioassayontology.org/bao#\")\n",
    "RCD = Namespace(\"http://purl.bioontology.org/ontology/RCD/\") #Read Codes, Clinical TermsVersion 3 (CTV3)\n",
    "AFO = Namespace(\"http://purl.allotrope.org/ontologies/result#\")\n",
    "OPB = Namespace(\"http://bhi.washington.edu/OPB#\") #Ontology for Physics for Biology\n",
    "NCI = Namespace(\"http://ncicb.nci.nih.gov/xml/owl/EVS/Thesaurus.owl#\") #thesaurus\n",
    "OAE = Namespace(\"http://purl.obolibrary.org/obo/\") #Ontology Adverse Effects\n",
    "FIX = Namespace(\"http://purl.org/obo/owl/FIX#\")\n",
    "OBO = Namespace(\"http://purl.obolibrary.org/obo/\")\n",
    "STY = Namespace(\"http://purl.bioontology.org/ontology/STY/\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "85cb609d-6ac1-42b5-86ca-8d9bdff769aa",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "79f2c6bb-7b7b-482f-a02d-0f0153d55f4b",
   "metadata": {},
   "source": [
    "## Size Node"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "37d7fe5b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Methods data size extraction\n",
    "\n",
    "def add_size_information(size_node, size_value, g):      \n",
    "    g.add((nanoparticle, npo.has_quality, size_node)) #size\n",
    "    g.add((size_node, RDF.type, PATO.PATO_0000117))\n",
    "    g.add((size_node, npo.has_unit_of_measure, npo.NPO_1246))\n",
    "    s = size_value.lower()\n",
    "    if str(s)==\"nan\" or str(s)==\"  \":\n",
    "        return\n",
    "    elif extract_size_kind(size_node, s, g):\n",
    "        extract_size_kind(size_node, s, g)\n",
    "    elif extract_medium(size_node, s, g):\n",
    "        extract_medium(size_node, s, g)\n",
    "    elif extract_data_type(size_node, s, g):\n",
    "        extract_data_type(size_node, s, g)  \n",
    "def extract_size_kind(size, data, g):\n",
    "    bn = BNode()\n",
    "    if any(re.sub(r'[\\W_]+', '', word) in size_dict.keys() for word in str(data).split()): #if any word characters exist in dictionary\n",
    "        k = [re.sub(r'[\\W_]+', '', word) for word in str(data).split() if re.sub(r'[\\W_]+', '', word) in size_dict.keys()][0]\n",
    "        g.add((size, SKOS.narrower, size_dict[k][0]))\n",
    "        g.add((size_dict[k][0], RDFS.label, Literal(size_dict[k][1], lang='en')))\n",
    "    elif \") = \" in size:\n",
    "        k = 'diameter'\n",
    "        g.add((size, SKOS.narrower, size_dict[k][0]))\n",
    "        g.add((size_dict[k][0], RDFS.label, Literal(size_dict[k][1], lang='en')))\n",
    "    else:\n",
    "        k = 'particle size'\n",
    "        g.add((size, SKOS.narrower, size_dict[k][0]))\n",
    "        g.add((size_dict[k][0], RDFS.label, Literal(size_dict[k][1], lang='en')))\n",
    "\n",
    "def extract_medium(size, data, g):\n",
    "    if any(re.sub(r'[\\W_]+', '', word) in medium_dict.keys() for word in str(data).split()):\n",
    "        k = [re.sub(r'[\\W_]+', '', word) for word in str(data).split() if re.sub(r'[\\W_]+', '', word) in medium_dict.keys()][0]\n",
    "        g.add((size, npo.contained_in, medium_dict[k][0]))\n",
    "        g.add((medium_dict[k][0], RDFS.label, Literal(medium_dict[k][1], lang='en')))\n",
    "\n",
    "\n",
    "def extract_data_type(size, data, g):\n",
    "    bn = BNode()\n",
    "    bn1 = BNode()\n",
    "    if 'up to ' in data:\n",
    "        upper = float(re.sub(r'[^0-9.]+', '', data))        #todo fix this\n",
    "        g.add((size, sio.SIO_000300, bn))\n",
    "        g.add((bn, RDF.type, bn1))\n",
    "        g.add((bn1, RDF.type, data_dict['range'][0]))\n",
    "        g.add((bn1, RDFS.label, data_dict['range'][1]))\n",
    "        g.add((bn, sio.SIO_000300, Literal(\"<\"+str(upper))))\n",
    "        g.add((bn, sbd.upper_limit, Literal(str(upper))))\n",
    "    elif 'grater than' in data:\n",
    "        lower = re.sub(r'[^0-9.]+', '', data.split('-')[0])\n",
    "        g.add((size, sio.SIO_000300, bn))\n",
    "        g.add((bn, RDF.type, bn1))\n",
    "        g.add((bn1, RDF.type, data_dict['range'][0]))\n",
    "        g.add((bn1, RDFS.label, data_dict['range'][1]))\n",
    "        g.add((bn, sio.SIO_000300, Literal(\">\"+str(lower))))\n",
    "        g.add((bn, sbd.lower_limit, Literal(str(lower))))\n",
    "    elif 'â±' in data:\n",
    "        if 'tem' in data:\n",
    "            return\n",
    "        lower = float(re.sub(r'[^0-9.]+', '', data.split('â±')[0]))-float(re.sub(r'[^0-9.]+', '', data.split('â±')[1]))\n",
    "        upper = float(re.sub(r'[^0-9.]+', '', data.split('â±')[0]))+float(re.sub(r'[^0-9.]+', '', data.split('â±')[1]))\n",
    "        g.add((size, sio.SIO_000300, bn))\n",
    "        g.add((bn, RDF.type, bn1))\n",
    "        g.add((bn1, RDF.type, data_dict['range'][0]))\n",
    "        g.add((bn1, RDFS.label, data_dict['range'][1]))\n",
    "        g.add((bn, sio.SIO_000300, Literal(str(lower) + '-' + str(upper))))\n",
    "        g.add((bn, sbd.lower_limit, Literal(str(lower))))\n",
    "        g.add((bn, sbd.upper_limit, Literal(str(upper)))) \n",
    "    elif '-' in data:\n",
    "        lower = re.sub(r'[^0-9.]+', '', data.split('-')[0])\n",
    "        upper = re.sub(r'[^0-9.]+', '', data.split('-')[1])\n",
    "        g.add((size, sio.SIO_000300, bn))\n",
    "        g.add((bn, RDF.type, bn1))\n",
    "        g.add((bn1, RDF.type, data_dict['range'][0]))\n",
    "        g.add((bn1, RDFS.label, data_dict['range'][1]))\n",
    "        g.add((bn, sio.SIO_000300, Literal(str(lower) + '-' + str(upper))))\n",
    "        g.add((bn, sbd.lower_limit, Literal(str(lower))))\n",
    "        g.add((bn, sbd.upper_limit, Literal(str(upper)))) \n",
    "    elif ',' in data:\n",
    "        for d in data.split(','):\n",
    "            g.add((size, sio.SIO_000300, bn))\n",
    "            g.add((bn, RDF.type, bn1))\n",
    "            g.add((bn1, RDF.type, data_dict['value'][0]))\n",
    "            g.add((bn1, RDFS.label, data_dict['value'][1]))\n",
    "            g.add((bn, sio.SIO_000300, Literal(re.sub(r'[^0-9.]+', '', d))))\n",
    "    elif 'average' in data:  \n",
    "        g.add((size, sio.SIO_000300, bn))\n",
    "        g.add((bn, RDF.type, bn1))\n",
    "        g.add((bn1, RDF.type, data_dict['average'][0]))\n",
    "        g.add((bn1, RDFS.label, data_dict['average'][1]))\n",
    "        g.add((bn, sio.SIO_000300, Literal(re.sub(r'[^0-9.]+', '', data))))\n",
    "    else:\n",
    "        g.add((size, sio.SIO_000300, bn))\n",
    "        g.add((bn, RDF.type, bn1))\n",
    "        g.add((bn1, RDF.type, data_dict['value'][0]))\n",
    "        g.add((bn1, RDFS.label, data_dict['value'][1]))\n",
    "        g.add((bn, sio.SIO_000300, Literal(re.sub(r'[^0-9.]+', '', data))))  # check if this works for everything\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5878d03e-858d-42fa-940b-63bb87966bf7",
   "metadata": {},
   "source": [
    "## Dictionaries"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74b9b490",
   "metadata": {},
   "source": [
    "### Nanoparticles dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "ab79177e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dictionaries nanoparticles\n",
    "general_type_dict = {'metal oxide': [npo.NPO_1541, Literal(\"Metal Oxide\", lang=\"en\")], \n",
    "                     'metal': [npo.NPO_1384, Literal(\"Metal\", lang=\"en\")], \n",
    "                     'carbon-based': [npo.NPO_836, Literal(\"Carbon-based\", lang=\"en\")], #biodegradable -> no carbon-based onto, neither organic\n",
    "                     'lipid-based': [npo.NPO_1552, Literal(\"Lipid-based\", lang=\"en\")], \n",
    "                     'polymeric': [npo.NPO_1375, Literal(\"Polymeric\", lang=\"en\")], \n",
    "                     'dendrimer': [npo.NPO_735, Literal(\"Dendrimer\", lang=\"en\")]}\n",
    "\n",
    "\n",
    "\n",
    "nms_dict = {\"Ag\": [npo.NPO_1892, Literal(\"Ag nanoparticle\")],\n",
    "            \"Ag2O\": [MESH.C040225, Literal(\"Disilver Oxide Ag2O\")], ###### MESH\n",
    "            \"Au\": [npo.NPO_401, Literal(\"Au nanopartice\")],\n",
    "            \"Al\": [npo.NPO_103, Literal(\"Al nanoparticle\")],\n",
    "            \"Fullerene C60\": [npo.NPO_730, Literal(\"Fullerene C60\")],\n",
    "            \"Fullerene C60 and C70\": [npo.NPO_686, Literal(\"Fullerene C60 and C70\")],\n",
    "            \"Fullerenes C60\": [npo.NPO_730, Literal(\"Fullerene C60\")],\n",
    "            \"(Fullerenes C60 and C70)\": [npo.NPO_686, Literal(\"Fullerene C60 and C70\")],\n",
    "            \"(Fe2O3)n(Fe3O4)m\": [npo.NPO_729, Literal(\"(Fe2O3)n(Fe3O4)m\")],\n",
    "            \"Fe2O3\": [npo.NPO_1550, Literal(\"Fe2O3\")],\n",
    "            \"Fe3O4\": [npo.NPO_1548, Literal(\"Fe3O4\")],\n",
    "            \"FeO\": [npo.NPO_1150, Literal(\"FeO\")],\n",
    "            \"(Single/Multiwalled nanotubes)\": [npo.NPO_606, Literal(\"Single/Multiwalled nanotubes\")],\n",
    "            \"CNT: Carbon nanotubes\": [npo.NPO_606, Literal(\"CNT: Carbon nanotubes\")],\n",
    "            \"MWCNT40nm-COOH\": [npo.NPO_354, Literal(\"MWCNT40nm-COOH\")],\n",
    "            \"MWCNTs (Multi-walled carbon nanotubes)\": [npo.NPO_354, Literal(\"MWCNTs (Multi-walled carbon nanotubes)\")],\n",
    "            \"R-TiO2\": [npo.NPO_1486, Literal(\"R-TiO2\")],\n",
    "            \"SWNTs: Single-walled nanotubes\": [npo.NPO_943, Literal(\"SWNTs: Single-walled nanotubes\")],\n",
    "            \"SiO2\": [npo.NPO_1373, Literal(\"SiO2\")],\n",
    "            \"TiO2\": [npo.NPO_1486, Literal(\"TiO2\")],\n",
    "            \"ZnO\": [npo.NPO_1542, Literal(\"ZnO\")],\n",
    "            \"Al2O3\": [obo.CHEBI_30187, Literal(\"Al2O3\")],\n",
    "            \"Co NPs\": [enm.ENM_9000248, Literal(\"Cobalt nanoparticle\")],\n",
    "            \"Co\": [obo.CHEBI_33888, Literal(\"Cobalt molecular entity\")],\n",
    "            \"CoO\": [enm.ENM_0000118, Literal(\"Cobalt (II) oxide nanoparticle\")],\n",
    "            \"Co3O4\": [enm.ENM_9000254, Literal(\"Co3O4 nanoparticle\")],\n",
    "            \"Co ions\": [obo.CHEBI_23336, Literal(\"Cobalt cations\")],\n",
    "            \"Co3O4\": [enm.ENM_9000254, Literal(\"Co3O4 nanoparticle\")],\n",
    "            \"CoFe2O4\": [MESH.C569492, Literal(\"cobalt ferrite (CoFe2O4)\")], ######### MESH\n",
    "            \"3Al2O3 2SiO2\": [MESH.C049037, Literal(\"Mullite 3Al2O3 2SiO2\")],\n",
    "            \"AlN\": [obo.CHEBI_50884, Literal(\"Aluminium nitride\")],\n",
    "            \"As2O5\": [MESH.C042120, Literal(\"Arsenic pentoxide\")],\n",
    "            \"BaO\": [MESH.C0174148, Literal(\"Barium oxide\")],\n",
    "            \"BeO\": [MESH.C0053349, Literal(\"Beryyllium oxide\")]}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d7934f3",
   "metadata": {},
   "source": [
    "### Size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "8d441cd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "size_dict = {'particle size': [npo.NPO_1694, \"Particle size\"], \n",
    "             'diameter': [obo.PATO_0001334, \"Diameter\"], \n",
    "             'radius': [obo.PATO_0002390, \"Radius\"], \n",
    "             'aggregation': [npo.NPO_1967, \"Aggregation\"], #class not realated to size\n",
    "             'length': [obo.PATO_0000122, \"Length\"]} \n",
    "\n",
    "medium_dict = {'water': [obo.CHEBI_15377, Literal(\"Water\")],\n",
    "               'pbs': [npo.NPO_1846, Literal(\"Phosphate Buffer Saline\")]}\n",
    "#                'ccm': [Literal(\"No NPO term\"), Literal(\"CCM\")]}   ########### need to add an ontology\n",
    "\n",
    "data_dict = {'value': [npo.NPO_1807, Literal(\"Size value\")],\n",
    "             'range': [STATO.STATO_0000035, Literal(\"Range\")],\n",
    "             'average': [npo.NPO_1800, Literal(\"Average\")], #NPO_1822 mean particle size\n",
    "             'median': [npo.NPO_1801, Literal(\"Median\")]}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "414a6f5a",
   "metadata": {},
   "source": [
    "### Shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "d9225e18",
   "metadata": {},
   "outputs": [],
   "source": [
    "shape_dict = {\n",
    "#     \"coarse porous surface with irregular pores\": [Literal(\"NPO term not defined\"), Literal(\"Not defined\")], #no ontology/Irregular?\n",
    "            \"elliptical\": [npo.NPO_850 , Literal(\"Elliptical\")],\n",
    "            \"fiber\": [npo.NPO_461 , Literal(\"Fiber\")], #rod-shaped\n",
    "#             \"film\": [Literal(\"NPO term not defined\"), Literal(\"Film\")], ########### need to add an ontology\n",
    "            \"hexagonal crystal system\": [npo.NPO_858 , Literal(\"Hexagonal\")], #polyhedral\n",
    "#             \"irregular\": [Literal(\"NPO term not defined\"), Literal(\"Irregular\")], ########### need to add an ontology\n",
    "            \"needle\": [npo.NPO_852, Literal(\"Needle\")],\n",
    "            \"pyramidal\": [npo.NPO_858 , Literal(\"Pyramidal\")], #polyhedral\n",
    "            \"spherical\": [npo.NPO_286 , Literal(\"Spherical\")],\n",
    "            \"spherical, grains, rods, or needles\": [npo.NPO_286 , Literal(\"Spherical\")],########### NEED TO FIX THIS\n",
    "            \"sphericity and circularity\": [npo.NPO_286 , Literal(\"Spherical\")],\n",
    "#             \"strip\": [Literal(\"NPO term not defined\"), Literal(\"Strip\")], ############# need to add an ontology\n",
    "            \"fiber (MWCNT)\": [npo.NPO_461 , Literal(\"Fiber\")], #rod-shaped\n",
    "            \"polyhedral\": [npo.NPO_858 , Literal(\"Polyhedral\")],\n",
    "            \"pseudo-spherical\": [npo.NPO_286 , Literal(\"Pseudo-spherical\")], #spherical\n",
    "            \"rod\": [npo.NPO_461 , Literal(\"Rod\")],\n",
    "#             \"slice-shaped\": [Literal(\"NPO term not defined\"), Literal(\"Slice-shaped\")],  ########### need to add an ontology\n",
    "            \"spherical (C60)\": [npo.NPO_286 , Literal(\"Spherical\")]} #spherical"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "b6302bdb",
   "metadata": {},
   "outputs": [],
   "source": [
    "model_dict = {'QSAR': [MESH.D021281, Literal(\"QSAR\", lang=\"en\")], \n",
    "              'QSPR': [MESH.D021281, Literal(\"QSPR\", lang=\"en\")] }"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "366484fa",
   "metadata": {},
   "source": [
    "### Endpoint Dictionaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "c6dbfafd",
   "metadata": {},
   "outputs": [],
   "source": [
    "endpointlog_dict = {'Cell': [STY.T025, Literal(\"Cell\", lang=\"en\")], \n",
    "                     'Organism': [STY.T001, Literal(\"Organism\", lang=\"en\")] }\n",
    "\n",
    "design_dict = {'In vitro': [obo.OBI_0001285, Literal(\"In vitro\")], \n",
    "                 'In vivo': [obo.OBI_0100026, Literal(\"In vivo\")]}\n",
    "\n",
    "specific_endpoint_dict = { \"Bacteria Escherichia Coli (E. Coli)\": [MESH.D004926, \"Bacteria Escherichia Coli (E. Coli)\"],\n",
    "                           \"Escherichia coli (bacteria)\": [MESH.D004926, \"Bacteria Escherichia Coli (E. Coli)\"],\n",
    "                            \"Immortalized rat L2 lung epithelial cells\": [RCD.X7A8D, \"Lung L2 (rat)\"],\n",
    "                            \"A549 (H)\": [MESH.D000072283, \"An adenocarcinoma cell line (human lung epithelial cells)\"],\n",
    "                            \"A549 human lung epithelial carcinoma cells\": [MESH.D000072283, \"An adenocarcinoma cell line (human lung epithelial cells)\"],\n",
    "                            \"A549 human lung epithelial cells\": [MESH.D000072283, \"An adenocarcinoma cell line (human lung epithelial cells)\"],\n",
    "                            \"Pancratic humane cancer cells (PaCa2)\": [obo.CLO_0050101, \"Pancratic humane cancer cells (PaCa2)\"],\n",
    "                            \"Human keratinocyte cell line (HaCaT)\": [MESH.D000084282, \"Human keratinocyte cell line (HaCaT)\"],\n",
    "                            \"Macrophage\": [obo.CL_0000235, \"Macrophage\"]}\n",
    "                                                                  \n",
    "endpoint_dict = {\"Cellular uptake\": [npo.NPO_296, \"Cellular uptake of extracellular material\"],\n",
    "    \"Cytotoxicity\": [BAO.BAO_0002993, \"Cytotoxicity assay\"],\n",
    "    \"Mutagenicity\": [enm.ENM_0000042, \"Mutagenicity\"],\n",
    "    \"Cell differentiation response\": [obo.OBI_0001429, \"Cell differentiation\"],\n",
    "    \"Exocytosis\": [MESH.D005089, \"Exocytosis\"],\n",
    "    \"Solubility in organic solvents\": [enm.ENM_9000082, \"Solubility in organic solvents\"], #<<<<<<< organic?\n",
    "    \"Solubility in water\": [npo.NPO_500, \"Solubility in water\"],\n",
    "    \"Solubility in chlorobenzene\": [enm.ENM_9000082, \"Solubility in organic solvents\"],\n",
    "    \"Poisson's ratio\": [OPB.OPB_01022, \"Poisson ratio\"],\n",
    "    \"LC structure\": [FIX.FIX_0000608, \"LC - Liquid Chromatography structure\" ],#<<<<<< straaaaange\n",
    "    \"Dispersion in organic solvents\": [npo.NPO_1969, \"Dispersion\"],#<<<<<<\n",
    "    \"Adsorption / removal (%)\": [NCI.C157206, \"Adsorption\"],\n",
    "    \"Zeta potential (Î¶)\": [npo.NPO_1302, \"Zeta potential\"],\n",
    "    \"Rodent lung inflammation\": [obo.OAE_000056, \"Lung inflamation AE\"], #<<< rodent..\n",
    "    \"Toxic Effect\": [BAO.BAO_0002189, \"Toxicity Assay\"],\n",
    "    \"ROS\": [obo.CHEBI_70982, \"ROS - reactive oxygen species\"]}"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "311602cd-a3ad-47ba-89b3-03453f1bcf41",
   "metadata": {},
   "source": [
    "# Main Code"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "245137ea-3864-4614-9be1-acf22e26cc72",
   "metadata": {},
   "source": [
    "## RDF formation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "99319907-da3e-4f67-ae77-5d59afc6fbca",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "g = Graph()\n",
    "g.bind(\"dc\", DC)\n",
    "g.bind(\"rdfs\", RDFS)\n",
    "g.bind(\"foaf\", FOAF)\n",
    "g.bind(\"dcterms\", DCTERMS)\n",
    "g.bind(\"dc\", DC)\n",
    "g.bind(\"void\", VOID)\n",
    "g.bind(\"rdf\", RDF)\n",
    "g.bind(\"xsd\", XSD)\n",
    "g.bind(\"eco\", ECO)\n",
    "g.bind(\"sbd\", sbd)\n",
    "g.bind(\"kb\", kb)\n",
    "g.bind(\"enm\", enm)\n",
    "g.bind(\"ncit\", ncit)\n",
    "g.bind(\"owl\", OWL)\n",
    "g.bind(\"sio\", sio)\n",
    "g.bind(\"CHEBI\", CHEBI)\n",
    "g.bind(\"SKOS\", SKOS)\n",
    "g.bind(\"PATO\", PATO)\n",
    "g.bind(\"STATO\", STATO)\n",
    "g.bind(\"MESH\", MESH)\n",
    "g.bind(\"OBI\", OBI)\n",
    "g.bind(\"CL\", CL)\n",
    "g.bind(\"void\", VOID)\n",
    "g.bind(\"PUBCHEM\", PUBCHEM)\n",
    "g.bind(\"npo\", npo)\n",
    "g.bind(\"BAO\", BAO)\n",
    "g.bind(\"RCD\", RCD)\n",
    "g.bind(\"AFO\", AFO)\n",
    "g.bind(\"OPB\", OPB)\n",
    "g.bind(\"NCI\", NCI)\n",
    "g.bind(\"OAE\", OAE)\n",
    "g.bind(\"FIX\", FIX)\n",
    "g.bind(\"CLO\", CLO)\n",
    "g.bind(\"STY\", STY)\n",
    "g.bind(\"OBO\", OBO)\n",
    "\n",
    "\n",
    "void_source = URIRef(\"https://h2020-sbd4nano.github.io/sbd-data-landscape\")\n",
    "doi_list = []\n",
    "df.at[46,\"algo\"] = \"Stepwise-MLR PLS\"\n",
    "df.at[46,\"algoName\"] = \"Stepwise_Multiple_Linear_Regression Partial_Least_Squares\"\n",
    "\n",
    "\n",
    "g.add((void_source, RDF.type, VOID.DatasetDescription))\n",
    "g.add((void_source, FOAF.page, URIRef(\"https://www.sbd4nano.eu/\")))\n",
    "g.add((void_source, DC.source, URIRef(\"https://doi.org/10.1016/j.comtox.2018.12.002\")))\n",
    "g.add((void_source, DC.title, Literal(\"Computational models for the assessment of manufactured nanomaterials\", lang=\"en\"))) \n",
    "\n",
    "for row in df.index[45:46]:\n",
    "    selected_row = df.loc[row]\n",
    "    ref = str(selected_row['Ref'])\n",
    "    \n",
    "################# Main Node #################    \n",
    "    \n",
    "    model = URIRef(kb + \"Model_\"+ str(selected_row['Ref']))\n",
    "    reference = URIRef(df.loc[row, 'DOI'])\n",
    "    nanoparticle = URIRef(model + \"/Nanoparticle\")\n",
    "    endpoint = URIRef(model + \"/Endpoint\")\n",
    "    qsar = URIRef(model + \"/QSAR\")\n",
    "    algo_bn= BNode()\n",
    "    qsar_bn = BNode()\n",
    "\n",
    "    g.add((model, RDF.type, sbd.model))\n",
    "    g.add((model, SKOS.narrower, qsar_bn))\n",
    "    g.add((qsar_bn, RDF.type, MESH.D021281))\n",
    "    g.add((qsar_bn, RDFS.label, Literal(str(selected_row[\"QSAR/QSPR\"]), lang='en')))\n",
    "\n",
    "    g.add((model, RDF.type, sbd.resource))\n",
    "    g.add((model, DCTERMS.source, reference)) \n",
    "    g.add((model, DCTERMS.subject, nanoparticle))\n",
    "    \n",
    "    g.add((model, MESH.mapped_from, algo_bn))\n",
    "    g.add((algo_bn, RDF.type, NCI.C16275))\n",
    "    g.add((NCI.C16275, RDFS.label, Literal(\"Algorithm\", lang='en'))) #### has part, endpoint\n",
    "\n",
    "    g.add((model, BAO.BAO_0090004, endpoint)) #### has part, endpoint\n",
    "#     g.add((BAO.BAO_0090004, RDFS.label, Literal(\"has part\", lang='en'))) #### has part, endpoint\n",
    "\n",
    "    if isinstance(selected_row['Remarks'], str):\n",
    "        remarks = selected_row['Remarks'].split()\n",
    "        remarks = \" \".join(remarks)\n",
    "        g.add((model, RDFS.comment, Literal(remarks, lang='en')))\n",
    "\n",
    "    \n",
    "################ Resource Node ###################    \n",
    "\n",
    "    if selected_row['DOI'] not in doi_list:\n",
    "        doi_list.append(selected_row['DOI'])\n",
    "        g.add((reference, RDF.type, sio.SIO_000176))\n",
    "        g.add((sio.SIO_000176, RDFS.label, Literal(\"Reference\")))\n",
    "        g.add((reference, DCTERMS.issued, Literal(int(selected_row['Year']))))\n",
    "        \n",
    "        if isinstance(selected_row['Title'], str):\n",
    "            g.add((reference, DCTERMS.title,  Literal(str(selected_row['Title']))))\n",
    "\n",
    "        #Contact person\n",
    "        for i, cp in enumerate(selected_row['Contact person'].split('\\n ')):\n",
    "            cp = cp.strip()\n",
    "            if \" \"  in cp:\n",
    "                contact_person_bnode = BNode()\n",
    "                g.add((reference, DCTERMS.mediator, contact_person_bnode))\n",
    "                g.add((contact_person_bnode, RDF.type, FOAF.Person))\n",
    "                g.add((contact_person_bnode, FOAF.name, Literal(str(cp)))) \n",
    "\n",
    "        #Authors\n",
    "        for i, author in enumerate(selected_row['Authors'].split('; ')):\n",
    "            authors_bnode = BNode()\n",
    "            g.add((reference, FOAF.maker, authors_bnode))\n",
    "            g.add((authors_bnode, RDF.type, FOAF.Person))\n",
    "            g.add((authors_bnode, FOAF.name, Literal(author)))\n",
    "            \n",
    "################ Endpoint Node ###################    \n",
    "    g.add((endpoint, RDF.type, BAO.BAO_0000179))\n",
    "    g.add((BAO.BAO_0000179, RDFS.label, Literal(\"Endpoint\", lang='en')))\n",
    "\n",
    "#Endpoint comment            \n",
    "    if isinstance(selected_row['endpointdescription'], str):\n",
    "        comment = selected_row['endpointdescription'].split()\n",
    "        comment = \" \".join(comment)\n",
    "        g.add((endpoint, RDFS.comment, Literal(comment, lang='en')))\n",
    "                  \n",
    "    \n",
    "#Endpoint level of organisation \n",
    "    if isinstance(selected_row['endpointlog'], str):\n",
    "        ep_list = selected_row['endpointlog'].split(\"s and \")\n",
    "        for i, ep in enumerate(ep_list):\n",
    "            if ep in endpointlog_dict:\n",
    "                g.add((endpoint, RDF.type, endpointlog_dict[ep][0]))\n",
    "                g.add((endpointlog_dict[ep][0], RDFS.label, endpointlog_dict[ep][1]))\n",
    "\n",
    "#Endpoint level of organisation details\n",
    "    if isinstance(selected_row['endpointlogdetails'], str):\n",
    "        epdet_list = selected_row['endpointlogdetails'].split(\"\\n\")\n",
    "        for i, ep in enumerate(epdet_list):\n",
    "            ep = ep.strip()\n",
    "            if ep in specific_endpoint_dict:\n",
    "                g.add((endpoint, SKOS.narrower, specific_endpoint_dict[ep][0]))\n",
    "                g.add((specific_endpoint_dict[ep][0], RDFS.label, Literal(specific_endpoint_dict[ep][1], lang='en')))\n",
    "            elif ep != \"\":\n",
    "                g.add((endpoint, SKOS.narrower, Literal(ep)))\n",
    "    \n",
    "#Endpoint design\n",
    "    if isinstance(selected_row['design'], str):\n",
    "        design_list = selected_row['design'].split(\" and \")\n",
    "        for i, dg in enumerate(design_list):\n",
    "            if dg in design_dict:\n",
    "                g.add((endpoint, BAO.BAO_0095009, design_dict[dg][0])) #has assay design method\n",
    "                g.add((design_dict[dg][0], RDFS.label, design_dict[dg][1]))\n",
    "\n",
    "#Endpoint quality \n",
    "    if isinstance(selected_row['quality'], str):\n",
    "        qual = selected_row['quality']\n",
    "        quality_bnode= BNode()\n",
    "        g.add((endpoint, BAO.BAO_0002662, quality_bnode))\n",
    "\n",
    "        if qual in endpoint_dict :\n",
    "            g.add((quality_bnode, RDF.type, endpoint_dict[qual][0]))\n",
    "            g.add((quality_bnode, RDFS.label, Literal(endpoint_dict[qual][1], lang='en')))\n",
    "            if isinstance(selected_row['comment'], str):\n",
    "                g.add((quality_bnode, RDFS.comment, Literal(selected_row['comment'], lang='en')))\n",
    "        else: \n",
    "            g.add((quality_bnode, RDF.type, Literal(qual)))\n",
    "            if isinstance(selected_row['comment'], str):\n",
    "                g.add((quality_bnode, RDFS.comment, Literal(selected_row['comment'], lang='en')))\n",
    "        \n",
    "                \n",
    "                \n",
    "################ Nanoparticle Node ###################  \n",
    "\n",
    "    g.add((nanoparticle, RDF.type, npo.NPO_707))\n",
    "    g.add((npo.NPO_707, RDFS.label, Literal(\"Nanoparticle\", lang='en')))\n",
    "    \n",
    "\n",
    "# General type of NM\n",
    "    if isinstance(selected_row['General type NMs'], str):\n",
    "        general_type_list = str(selected_row['General type NMs']).split(\"\\n \")\n",
    "        for i, gen in enumerate(general_type_list):\n",
    "            gen = gen.strip().lower()\n",
    "            if gen in general_type_dict.keys():\n",
    "                g.add((nanoparticle, RDF.type, general_type_dict[gen][0]))\n",
    "                g.add((general_type_dict[gen][0], RDFS.label, general_type_dict[gen][1]))\n",
    "\n",
    "# Shape type of NM\n",
    "    if isinstance(selected_row['Shape NM'], str):\n",
    "        shape_list = str(selected_row['Shape NM']).split(\"\\n \")\n",
    "        for i, shape in enumerate(shape_list):\n",
    "            shape = shape.strip().lower()\n",
    "            shape_bnode = BNode()\n",
    "            shape_detail_bnode =BNode()\n",
    "            g.add((nanoparticle, npo.has_quality, shape_bnode))\n",
    "            g.add((shape_bnode, RDF.type, npo.NPO_274)) #shape\n",
    "#             g.add((shape_bnode, SKOS.narrower, shape_detail_bnode))\n",
    "\n",
    "            if shape in shape_dict.keys():\n",
    "                g.add((shape_bnode, SKOS.narrower, shape_dict[shape][0]))\n",
    "                g.add((shape_dict[shape][0], RDFS.label, shape_dict[shape][1]))\n",
    "            else:\n",
    "                g.add((shape_bnode, SKOS.narrower, Literal(shape, lang=\"en\")))\n",
    "\n",
    "#Coating of NM\n",
    "    if isinstance(selected_row['Coating NM'], str):\n",
    "        coating_list = str(selected_row['Coating NM']).split(\"\\n \")\n",
    "        for i, coating in enumerate(coating_list):\n",
    "            coating = coating.strip()\n",
    "            coating_bnode = BNode()\n",
    "\n",
    "            if coating != \"\":\n",
    "                g.add((nanoparticle, npo.has_part, coating_bnode))                   \n",
    "                g.add((coating_bnode, RDF.type, npo.NPO_1962)) #shape\n",
    "                g.add((npo.NPO_1962, RDFS.label, Literal(\"Surface coating\",lang='en')))\n",
    "\n",
    "                if coating in df_coatings['nm_unique'].values:\n",
    "\n",
    "                    coating_row = df_coatings[df_coatings['nm_unique']==coating]\n",
    "                    cid = str(coating_row['CID'].iloc[0])\n",
    "                    if cid != \"0\":\n",
    "                        g.add((coating_bnode, SKOS.narrower, URIRef(PUBCHEM + cid)))\n",
    "                        g.add((URIRef(PUBCHEM + cid),RDFS.label, Literal(coating_row['IUPACName'].iloc[0])))\n",
    "                else:\n",
    "                    print(selected_row['Ref'],coating)\n",
    "                    g.add((coating_bnode, SKOS.narrower, Literal(coating, lang='en')))\n",
    "\n",
    "#Size of NM\n",
    "    size = URIRef(nanoparticle + \"/Size\")\n",
    "\n",
    "#     if isinstance(selected_row['Size (nm)'], str):\n",
    "#         size_list = str(selected_row['Size (nm)']).split(\"\\n \")\n",
    "#         g.add((nanoparticle, npo.has_quality, obo.PATO_0000117)) #size\n",
    "#         g.add((obo.PATO_0000117, RDFS.label, Literal(\"Size\",lang='en')))\n",
    "#         g.add((obo.PATO_0000117, npo.has_unit_of_measure, npo.NPO_1246))\n",
    "#         g.add((npo.NPO_1246, RDFS.label, Literal(\"Nanometer\",lang='en')))\n",
    "\n",
    "#         if len(size_list)>1:\n",
    "#             for i, value in enumerate(size_list):\n",
    "#                 value = value.strip()\n",
    "#                 if value != \"\":\n",
    "#                     add_size_information(obo.PATO_0000117, value, g)\n",
    "#         else:\n",
    "#             add_size_information(obo.PATO_0000117, size_list[0], g)\n",
    "            \n",
    "            \n",
    "    if isinstance(selected_row['Size (nm)'], str):\n",
    "        size_list = str(selected_row['Size (nm)']).split(\"\\n \")\n",
    "        if len(size_list)>1:\n",
    "            size_node_list = [URIRef(size + \"_\" + str(i)) for i in range(len(size_list))]\n",
    "            for i, size_node in enumerate(size_node_list):\n",
    "                size_list[i] = size_list[i].strip()\n",
    "                if size_list[i] != \"\":\n",
    "\n",
    "                    add_size_information(size_node, size_list[i], g)\n",
    "        else:\n",
    "            add_size_information(size, size_list[0], g)\n",
    "            \n",
    "#Kind of NM\n",
    "        if isinstance(selected_row['List of NMs'], str):\n",
    "            nms_list = str(selected_row['List of NMs']).split(\"\\n \")\n",
    "            for np_kind in nms_list:\n",
    "                np_kind = np_kind.strip()   \n",
    "                if np_kind in nms_dict.keys():\n",
    "                    g.add((nanoparticle, SKOS.narrower, nms_dict[np_kind][0]))     \n",
    "                    g.add((nms_dict[np_kind][0], RDFS.label, nms_dict[np_kind][1]))\n",
    "                elif np_kind in df_nms['nm_unique'].values:\n",
    "                    nms_row = df_nms[df_nms['nm_unique']==np_kind]\n",
    "                    g.add((nanoparticle, SKOS.narrower, URIRef(PUBCHEM + str(nms_row['CID'].iloc[0]))))\n",
    "                    g.add((URIRef(PUBCHEM + str(nms_row['CID'].iloc[0])), RDFS.label, Literal(nms_row['IUPACName'].iloc[0])))\n",
    "                elif np_kind != \"\":\n",
    "                    g.add((nanoparticle, SKOS.narrower, Literal(np_kind)))\n",
    "\n",
    "                \n",
    "################ QSAR Node ###################    \n",
    " \n",
    "    if isinstance(selected_row['algoName'], str):\n",
    "        algoName_list = selected_row['algoName'].split(\" \")\n",
    "        for i, algoName in enumerate(algoName_list):\n",
    "            algoName = algoName.replace(\"_\",\" \")\n",
    "            algoName = algoName.strip()\n",
    "            g.add((algo_bn, SKOS.narrower, Literal(algoName, lang='en')))\n",
    "\n",
    "#             g.add((NCI.C16275, SKOS.narrower, Literal(algoName, lang='en'))) #### has part, endpoint\n",
    "\n",
    "            \n",
    "    if isinstance(selected_row['software'], str):\n",
    "        software = selected_row['software'].strip()\n",
    "        software = software+\" software\"\n",
    "        g.add((algo_bn, BAO.BAO_0090006, Literal(software, lang='en')))\n",
    "#         g.add((BAO.BAO_0090006, RDFS.label, Literal(\"derives from\", lang='en')))\n",
    "\n",
    "\n",
    "Turtle = g.serialize(format='n3', destination='RDFnano.txt')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "88f41dac",
   "metadata": {},
   "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>Unnamed: 0</th>\n",
       "      <th>Ref</th>\n",
       "      <th>Model name</th>\n",
       "      <th>Contact person</th>\n",
       "      <th>Contact person email address</th>\n",
       "      <th>Authors</th>\n",
       "      <th>Year</th>\n",
       "      <th>Title</th>\n",
       "      <th>Journal</th>\n",
       "      <th>DOI</th>\n",
       "      <th>...</th>\n",
       "      <th>endpointlogdetails</th>\n",
       "      <th>endpoint</th>\n",
       "      <th>endpointdescription</th>\n",
       "      <th>design</th>\n",
       "      <th>quality</th>\n",
       "      <th>comment</th>\n",
       "      <th>algo</th>\n",
       "      <th>algoName</th>\n",
       "      <th>algocomment</th>\n",
       "      <th>software</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>45</th>\n",
       "      <td>45</td>\n",
       "      <td>25f</td>\n",
       "      <td>Ensemble Learning for predicting biological ac...</td>\n",
       "      <td>Kunwar P. Singh</td>\n",
       "      <td>kpsingh_52@yahoo.com\\n  \\n  kunwarpsingh@gmail...</td>\n",
       "      <td>K. P. Singh; S. Gupta</td>\n",
       "      <td>2014</td>\n",
       "      <td>Nano-QSAR modeling for predicting biological a...</td>\n",
       "      <td>RSC Advances</td>\n",
       "      <td>http://doi.org/10.1039/c4ra01274g</td>\n",
       "      <td>...</td>\n",
       "      <td>THP-1 (human monocytic cell line) differenciat...</td>\n",
       "      <td>In vitro - Cytotoxicity - measured as cellular...</td>\n",
       "      <td>Cellular viability was determined on the basis...</td>\n",
       "      <td>In vitro</td>\n",
       "      <td>Cytotoxicity</td>\n",
       "      <td>measured as cellular viability by determining ...</td>\n",
       "      <td>EL DTF DTB</td>\n",
       "      <td>Ensable_learning Decision_Tree_Forest Decision...</td>\n",
       "      <td>Both models were applied to obtain a regressio...</td>\n",
       "      <td>NaN</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1 rows × 47 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "    Unnamed: 0  Ref                                         Model name  \\\n",
       "45          45  25f  Ensemble Learning for predicting biological ac...   \n",
       "\n",
       "     Contact person                       Contact person email address  \\\n",
       "45  Kunwar P. Singh  kpsingh_52@yahoo.com\\n  \\n  kunwarpsingh@gmail...   \n",
       "\n",
       "                  Authors  Year  \\\n",
       "45  K. P. Singh; S. Gupta  2014   \n",
       "\n",
       "                                                Title       Journal  \\\n",
       "45  Nano-QSAR modeling for predicting biological a...  RSC Advances   \n",
       "\n",
       "                                  DOI  ...  \\\n",
       "45  http://doi.org/10.1039/c4ra01274g  ...   \n",
       "\n",
       "                                   endpointlogdetails  \\\n",
       "45  THP-1 (human monocytic cell line) differenciat...   \n",
       "\n",
       "                                             endpoint  \\\n",
       "45  In vitro - Cytotoxicity - measured as cellular...   \n",
       "\n",
       "                                  endpointdescription    design       quality  \\\n",
       "45  Cellular viability was determined on the basis...  In vitro  Cytotoxicity   \n",
       "\n",
       "                                              comment        algo  \\\n",
       "45  measured as cellular viability by determining ...  EL DTF DTB   \n",
       "\n",
       "                                             algoName  \\\n",
       "45  Ensable_learning Decision_Tree_Forest Decision...   \n",
       "\n",
       "                                          algocomment software  \n",
       "45  Both models were applied to obtain a regressio...      NaN  \n",
       "\n",
       "[1 rows x 47 columns]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.loc[df['Ref']==\"25f\"]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cbac01ec",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72d7be10",
   "metadata": {},
   "outputs": [],
   "source": [
    "df.loc[df['Ref']==\"25f\"]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "557f528f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}