geocoding

geocoding.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "93287571-6645-46b2-a0a8-4eb7af58a4bf",
   "metadata": {},
   "source": [
    "# Address Geocoding\n",
    "### V2 = Raw Address Strings + chatGPT Address Formatting + Google Geocoding API"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1d665e72-8ade-49f3-a426-1c345bb0dd12",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import requests\n",
    "import random\n",
    "import geopy.distance\n",
    "\n",
    "import random\n",
    "import time\n",
    "\n",
    "import sys\n",
    "sys.path.insert(0, '/home/pmarsh/.local/bin')\n",
    "import openai"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "715ed02b-7cbd-4e02-ab82-7dc97ec8afc5",
   "metadata": {},
   "outputs": [],
   "source": [
    "Google_API_key = 'xxxxxx' \n",
    "\n",
    "def google_address(address):\n",
    "    geo_url = 'https://maps.googleapis.com/maps/api/geocode/json'\n",
    "    my_address = {'key':Google_API_key,\n",
    "                  #'address': address['address1'] + 'Johannesburg, south africa', \n",
    "                  'address': address,\n",
    "                  'language': 'en'}\n",
    "    response = requests.get(geo_url, params = my_address)\n",
    "    return response.json()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "788fdc05-3a4f-4e9b-90e3-558ad0ed5587",
   "metadata": {},
   "outputs": [],
   "source": [
    "def google_result_quality(res):\n",
    "    quality = 'fail'\n",
    "    if res['status'] == 'OK':\n",
    "        lat, lon = res['results'][0]['geometry']['location'].values()\n",
    "        if (lat > -28) & (lat < -24) & (lon > 26) & (lon < 31):\n",
    "            if 'bounds' not in list(res['results'][0]['geometry']):\n",
    "                quality = 'exact'\n",
    "            else:\n",
    "                lat1, lon1 = res['results'][0]['geometry']['bounds']['northeast'].values()\n",
    "                lat2, lon2 = res['results'][0]['geometry']['bounds']['southwest'].values()\n",
    "                dist = geopy.distance.geodesic((lat1, lon1), (lat2,lon2)).km\n",
    "                if dist <= 1:\n",
    "                    quality = '1km'\n",
    "                elif dist <= 5:\n",
    "                    quality = '5km'\n",
    "                elif dist <= 20:\n",
    "                    quality = '20km'\n",
    "                else:\n",
    "                    quality = 'fail'\n",
    "    return quality"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "35813416-ec93-424a-8292-bdcf28fe2f02",
   "metadata": {},
   "outputs": [],
   "source": [
    "def return_google_api_string(openai_response, keys, address):\n",
    "    try:\n",
    "        answer = openai_response.choices[0].message.content\n",
    "        answer_list = answer.split(',')\n",
    "        answer_dict = {}\n",
    "        for a in answer_list:\n",
    "            key,value = a.split(':')\n",
    "            answer_dict[key.strip(' ')] = value.strip(' ')\n",
    "            goole_api_query_list = []\n",
    "        for key in keys:\n",
    "            if not answer_dict[key] == 'NAN':\n",
    "                goole_api_query_list.append(answer_dict[key])\n",
    "        google_api_string = ' '.join(goole_api_query_list)\n",
    "        ai_status = 'good'\n",
    "    except:\n",
    "        print('chatGPT failed')\n",
    "        google_api_string = address\n",
    "        ai_status = 'fail'\n",
    "        answer_dict = {}\n",
    "    return answer_dict, google_api_string, ai_status"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1889384a-2b2a-4bf4-85c2-fbac958179e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_openai_response(address):\n",
    "    address_example = 'Hillbrow, 24 rose house 144 lowlands street near JHB water tanks.' # this is a fake addrress\n",
    "    \n",
    "    address_example_answer = 'street number: 144, street name: lowlands Street, building number: 24, building name: rose house, complex name: NAN, complex number: NAN, suburb name: Hillbrow, city name: Johannesburg, province name: NAN, country name: NAN, nearest street corner: NAN, nearest landmark: Johannesburg Water Tanks'\n",
    "    \n",
    "    catagories = 'street number, street name, building number, building name, complex name, complex number, suburb name, city name, province name, country name, nearest street corner, nearest landmark'\n",
    "    \n",
    "    prompts =  [{\"role\": \"system\", \"content\": \"Assistant is an intelligent chatbot designed to return cleaned and categorized data as python list. Only return the requested data no context\"},\n",
    "                {\"role\": \"user\", \"content\": f\"Given an address description. First correct spelling errors and expand abbreviations. Then catagorise the address string into the following categories: '{catagories}'. If there is no clear values for a catagory return NAN. Only return the categorized address list.\"},\n",
    "                {\"role\": \"assistant\", \"content\": \"Sure please give me an address_example\"},\n",
    "                {\"role\": \"user\", \"content\": f\"{address_example}\"},\n",
    "                {\"role\": \"assistant\", \"content\": f\"{address_example_answer}\"},\n",
    "                {\"role\": \"user\", \"content\": f\"{address}\"}\n",
    "                ]\n",
    "    try:\n",
    "        openai_response = openai.ChatCompletion.create(model=\"gpt-3.5-turbo\", messages=prompts)\n",
    "    except:    #the below is a bit of a hack but the openai API is really unstable and I don't want to retry more than once.\n",
    "        time.sleep(5)\n",
    "        try:\n",
    "            openai_response = openai.ChatCompletion.create(model=\"gpt-3.5-turbo\", messages=prompts)\n",
    "        except:\n",
    "            openai_response = {}\n",
    "    return openai_response"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "353ebe38-ffdf-405f-b911-cc07a63392db",
   "metadata": {},
   "outputs": [],
   "source": [
    "open_ai_key = 'xxxxxxx' \n",
    "open_ai_org = 'xxxxx'\n",
    "\n",
    "openai.organization = open_ai_org\n",
    "openai.api_key = open_ai_key"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d7408d7e-6933-436e-8196-240077661401",
   "metadata": {},
   "outputs": [],
   "source": [
    "address_paths = {'dvr' : '/terra/projects/heat_center/incoming/RP2/health/DRV_052/Data/DRV pt_address.csv',\n",
    "                'advance' : '/terra/projects/heat_center/incoming/RP2/health/ADVANCE/Data/ADVANCE pt_address.csv',\n",
    "                'd4t' : '/terra/projects/heat_center/incoming/RP2/health/D4T/Data/address.csv'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "668be60b-55a4-44b7-bd29-fb24229a409b",
   "metadata": {},
   "outputs": [],
   "source": [
    "raw_address_list = list(pd.read_csv(address_paths['dvr']).iloc[:,1]) + list(pd.read_csv(address_paths['d4t']).iloc[:,1]) + list(pd.read_csv(address_paths['advance']).iloc[:,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34b81d4a-2678-43a4-aaaa-abf9abd61ab8",
   "metadata": {},
   "source": [
    "Previous efforts have had some more success using a dataset that has been broken down into street, suburb, town, complex etc. rather than one big messy string. I am hoping we can use chatGPT to split the string up for us."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "81706add-c35a-432c-9dc3-ee2c00354d95",
   "metadata": {},
   "outputs": [],
   "source": [
    "def return_geocode_success_rate_from_random_sample_with_chatgpt(address_list):\n",
    "    results = []\n",
    "    for address in address_list:\n",
    "        openai_response = get_openai_response(address)\n",
    "        keys = ['street number','street name','building number','building name','complex name','complex number','suburb name','city name','province name','country name']\n",
    "        answer_dict, goole_api_query, ai_status = return_google_api_string(openai_response, keys, address)\n",
    "        result = google_address(goole_api_query)\n",
    "        quality = google_result_quality(result)\n",
    "        # maybe try nearest landmark \n",
    "        if ai_status == 'good':\n",
    "            if quality == 'exact' or '1km':\n",
    "                pass\n",
    "            else:\n",
    "                if not answer_dict['nearest landmark'] == 'NAN':\n",
    "                    keys = ['nearest landmark','suburb name','city name','province name','country name']\n",
    "                    goole_api_query = return_google_api_string(keys)\n",
    "                    result_2 = google_address(goole_api_query)\n",
    "                    quality_2 = google_result_quality(result_2)\n",
    "                    if quality_2 == 'exact' or '1km':\n",
    "                        quality, result = quality_2, result_2\n",
    "                        print('improved by landmark !')\n",
    "            # maybe try nearest corner street\n",
    "            #google maps api actually can't interpret corner of x and y so no point in trying this type of query\n",
    "            #checking the overlap of the bounding boxes from two results could work\n",
    "            if quality == 'exact' or '1km':\n",
    "                pass\n",
    "            else:\n",
    "                if not answer_dict['nearest street corner'] == 'NAN':\n",
    "                    keys = ['nearest street corner','suburb name','city name','province name','country name']\n",
    "                    goole_api_query = return_google_api_string(keys)\n",
    "                    result_2 = google_address(goole_api_query)\n",
    "                    quality_2 = google_result_quality(result_2)\n",
    "                    if quality_2 == 'exact' or '1km':\n",
    "                        quality, result = quality_2, result_2\n",
    "                        print('improved by nearest street')\n",
    "        results.append(quality)\n",
    "    sub_1km = [res for res in results if res in ['exact','1km']]\n",
    "    sub_5km = [res for res in results if res in ['exact','1km','5km']]\n",
    "    sub_20km = [res for res in results if res in ['exact','1km','5km','20km']]\n",
    "    n = len(address_list)\n",
    "    return (len(sub_1km)/n, len(sub_5km)/n, len(sub_20km)/n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8c17bdc0-0a81-4daf-85bb-be72ec3ee2bb",
   "metadata": {},
   "outputs": [],
   "source": [
    "def return_geocode_success_rate_from_random_sample(address_list):\n",
    "    n = len(address_list)\n",
    "    results = []\n",
    "    for address in address_list:\n",
    "        results.append(google_address(address))\n",
    "    results_ok = [res for res in results if res['status'] == 'OK']\n",
    "    lats = []\n",
    "    lons = []\n",
    "    results_ok_in_Jburg = []\n",
    "    for res in results_ok:\n",
    "        lat, lon = res['results'][0]['geometry']['location'].values()\n",
    "        if (lat > -28) & (lat < -24) & (lon > 26) & (lon < 31):\n",
    "            lats.append(lat)\n",
    "            lons.append(lon)\n",
    "            results_ok_in_Jburg.append(res)\n",
    "    results_ok_in_Jburg_exact = [res for res in results_ok_in_Jburg if 'bounds' not in list(res['results'][0]['geometry'])]\n",
    "    approx = [res for res in results_ok_in_Jburg if res not in results_ok_in_Jburg_exact]\n",
    "    sub_1km = []\n",
    "    sub_5km = []\n",
    "    sub_20km = []\n",
    "    for res in approx:\n",
    "        lat1, lon1 = res['results'][0]['geometry']['bounds']['northeast'].values()\n",
    "        lat2, lon2 = res['results'][0]['geometry']['bounds']['southwest'].values()\n",
    "        dist = geopy.distance.geodesic((lat1, lon1), (lat2,lon2)).km\n",
    "        if dist <= 1:\n",
    "            sub_1km.append(res)\n",
    "        if dist <= 5:\n",
    "            sub_5km.append(res)\n",
    "        if dist <= 20:\n",
    "            sub_20km.append(res)\n",
    "    return len(sub_1km+results_ok_in_Jburg_exact)/n, len(sub_5km+results_ok_in_Jburg_exact)/n, len(sub_20km+results_ok_in_Jburg_exact)/n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "1e593ff2-db25-44ac-9bb7-8db0590bb04a",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "normal (0.45, 0.85, 0.9)\n",
      "gpt (0.7, 0.85, 0.95)\n",
      "normal (0.35, 0.55, 0.65)\n",
      "gpt (0.4, 0.7, 0.8)\n",
      "normal (0.3, 0.5, 0.65)\n",
      "chatGPT failed\n",
      "chatGPT failed\n",
      "gpt (0.45, 0.55, 0.7)\n",
      "normal (0.35, 0.55, 0.6)\n",
      "chatGPT failed\n",
      "gpt (0.5, 0.6, 0.65)\n",
      "normal (0.25, 0.65, 0.65)\n",
      "chatGPT failed\n",
      "gpt (0.55, 0.7, 0.7)\n",
      "normal (0.35, 0.5, 0.55)\n",
      "gpt (0.55, 0.8, 0.85)\n",
      "normal (0.35, 0.65, 0.65)\n",
      "gpt (0.75, 0.9, 0.9)\n",
      "normal (0.55, 0.6, 0.6)\n",
      "chatGPT failed\n",
      "gpt (0.5, 0.65, 0.7)\n",
      "normal (0.5, 0.7, 0.75)\n",
      "gpt (0.7, 0.85, 0.85)\n",
      "normal (0.25, 0.6, 0.65)\n",
      "gpt (0.55, 0.6, 0.65)\n"
     ]
    }
   ],
   "source": [
    "results = []\n",
    "results_with_GPT = []\n",
    "for i in range(10):\n",
    "    address_list = random.sample(raw_address_list, 20)\n",
    "    res = return_geocode_success_rate_from_random_sample(address_list)\n",
    "    results.append(res)\n",
    "    print('normal', res)\n",
    "    res_with_GPT = return_geocode_success_rate_from_random_sample_with_chatgpt(address_list)\n",
    "    results_with_GPT.append(res_with_GPT)\n",
    "    print('gpt', res_with_GPT)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "62a2cac6-240d-427a-8149-b837c9318def",
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "54571744-f963-49fd-aef1-bfcb0ebce2e3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = sns.boxplot(np.array(results_with_GPT))\n",
    "ax.set_ylim([0, 1])  \n",
    "ax.set_xticklabels(['1km', '5km' ,'20km'])\n",
    "ax.set_title(f'With GPT - sample size = {len(results_with_GPT)} * 20')\n",
    "plt.savefig('withGPT.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "091abeb8-3185-4446-a1ba-8696dcf18974",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "ax = sns.boxplot(np.array(results))\n",
    "ax.set_ylim([0, 1])  \n",
    "ax.set_xticklabels(['1km', '5km' ,'20km'])\n",
    "ax.set_title(f'Without GPT - sample size = {len(results)} * 20')\n",
    "plt.savefig('withoutGPT.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "3c29f579-608f-4eb7-b9e4-103ed4e74579",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1778"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(raw_address_list)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Pangeo",
   "language": "python",
   "name": "pangeo"
  },
  "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}