{ "cells": [ { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Requirement already satisfied: OpenHowNet in d:\\bianyisoftware\\python\\lib\\site-packages (0.0.1a8)" ] }, { "name": "stderr", "output_type": "stream", "text": [ "DEPRECATION: Loading egg at d:\\bianyisoftware\\python\\lib\\site-packages\\vboxapi-1.0-py3.11.egg is deprecated. pip 24.3 will enforce this behaviour change. A possible replacement is to use pip for package installation. Discussion can be found at https://github.com/pypa/pip/issues/12330" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Requirement already satisfied: anytree in d:\\bianyisoftware\\python\\lib\\site-packages (from OpenHowNet) (2.4.3)\n", "Requirement already satisfied: tqdm in d:\\bianyisoftware\\python\\lib\\site-packages (from OpenHowNet) (4.31.1)\n", "Requirement already satisfied: requests in d:\\bianyisoftware\\python\\lib\\site-packages (from OpenHowNet) (2.22.0)\n", "Requirement already satisfied: six>=1.9.0 in d:\\bianyisoftware\\python\\lib\\site-packages (from anytree->OpenHowNet) (1.16.0)\n", "Requirement already satisfied: chardet<3.1.0,>=3.0.2 in d:\\bianyisoftware\\python\\lib\\site-packages (from requests->OpenHowNet) (3.0.4)\n", "Requirement already satisfied: idna<2.9,>=2.5 in d:\\bianyisoftware\\python\\lib\\site-packages (from requests->OpenHowNet) (2.8)\n", "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in d:\\bianyisoftware\\python\\lib\\site-packages (from requests->OpenHowNet) (1.25.11)\n", "Requirement already satisfied: certifi>=2017.4.17 in d:\\bianyisoftware\\python\\lib\\site-packages (from requests->OpenHowNet) (2024.7.4)\n", "Requirement already satisfied: nltk in d:\\bianyisoftware\\python\\lib\\site-packages (3.8.1)" ] }, { "name": "stderr", "output_type": "stream", "text": [ "DEPRECATION: Loading egg at d:\\bianyisoftware\\python\\lib\\site-packages\\vboxapi-1.0-py3.11.egg is deprecated. pip 24.3 will enforce this behaviour change. A possible replacement is to use pip for package installation. Discussion can be found at https://github.com/pypa/pip/issues/12330\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "Requirement already satisfied: click in d:\\bianyisoftware\\python\\lib\\site-packages (from nltk) (8.1.7)\n", "Requirement already satisfied: joblib in d:\\bianyisoftware\\python\\lib\\site-packages (from nltk) (1.3.2)\n", "Requirement already satisfied: regex>=2021.8.3 in d:\\bianyisoftware\\python\\lib\\site-packages (from nltk) (2023.10.3)\n", "Requirement already satisfied: tqdm in d:\\bianyisoftware\\python\\lib\\site-packages (from nltk) (4.31.1)\n", "Requirement already satisfied: colorama in d:\\bianyisoftware\\python\\lib\\site-packages (from click->nltk) (0.4.6)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "DEPRECATION: Loading egg at d:\\bianyisoftware\\python\\lib\\site-packages\\vboxapi-1.0-py3.11.egg is deprecated. pip 24.3 will enforce this behaviour change. A possible replacement is to use pip for package installation. Discussion can be found at https://github.com/pypa/pip/issues/12330" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Requirement already satisfied: anytree==2.4.3 in d:\\bianyisoftware\\python\\lib\\site-packages (2.4.3)" ] }, { "name": "stderr", "output_type": "stream", "text": [ "\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "Requirement already satisfied: tqdm==4.31.1 in d:\\bianyisoftware\\python\\lib\\site-packages (4.31.1)\n", "Requirement already satisfied: requests==2.22.0 in d:\\bianyisoftware\\python\\lib\\site-packages (2.22.0)" ] }, { "name": "stdout", "output_type": "stream", "text": [ "\n", "Requirement already satisfied: six>=1.9.0 in d:\\bianyisoftware\\python\\lib\\site-packages (from anytree==2.4.3) (1.16.0)\n", "Requirement already satisfied: chardet<3.1.0,>=3.0.2 in d:\\bianyisoftware\\python\\lib\\site-packages (from requests==2.22.0) (3.0.4)\n", "Requirement already satisfied: idna<2.9,>=2.5 in d:\\bianyisoftware\\python\\lib\\site-packages (from requests==2.22.0) (2.8)\n", "Requirement already satisfied: urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1 in d:\\bianyisoftware\\python\\lib\\site-packages (from requests==2.22.0) (1.25.11)\n", "Requirement already satisfied: certifi>=2017.4.17 in d:\\bianyisoftware\\python\\lib\\site-packages (from requests==2.22.0) (2024.7.4)\n" ] } ], "source": [ "!pip install OpenHowNet\n", "!pip install nltk\n", "!pip install anytree==2.4.3 tqdm==4.31.1 requests==2.22.0" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "openhownet_data.zip: 107433KB [00:11, 9751.99KB/s] \n", "[nltk_data] Downloading package wordnet to\n", "[nltk_data] C:\\Users\\sky\\AppData\\Roaming\\nltk_data...\n", "[nltk_data] Package wordnet is already up-to-date!\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "Mapped result saved to mapped_result.json\n", "Mapped result saved to mapped_result2.json\n" ] } ], "source": [ "import OpenHowNet\n", "import json\n", "from nltk.corpus import wordnet as wn\n", "import nltk\n", "\n", "# Download HowNet data (required for first-time use)\n", "OpenHowNet.download()\n", "\n", "# Download WordNet data (required for first-time use)\n", "nltk.download('wordnet')\n", "\n", "# Create a HowNet object\n", "hownet_dict = OpenHowNet.HowNetDict()\n", "\n", "# Initialize HowNet sememe similarity calculation\n", "hownet_dict.initialize_sememe_similarity_calculation()\n", "\n", "# Extract semantic data from HowNet\n", "def get_hownet_semantics(word, language=\"zh\"):\n", " result_list = hownet_dict.get(word, language=language)\n", " if not result_list:\n", " return None\n", " \n", " # Extract definition, examples, and semantic relationships\n", " semantics = {\n", " \"word\": word,\n", " \"definition\": result_list[0].get(\"def\", \"\"),\n", " \"examples\": result_list[0].get(\"examples\", []),\n", " \"sememes\": result_list[0].get(\"sememes\", [])\n", " }\n", " \n", " return semantics\n", "\n", "# Extract semantic data from WordNet\n", "def get_wordnet_semantics(word):\n", " synsets = wn.synsets(word)\n", " if not synsets:\n", " return None\n", "\n", " # Extract definition, examples, and semantic relationships\n", " semantics = {\n", " \"word\": word,\n", " \"definition\": synsets[0].definition(),\n", " \"examples\": synsets[0].examples(),\n", " \"hypernyms\": [hypernym.name().split('.')[0] for hypernym in synsets[0].hypernyms()],\n", " \"hyponyms\": [hyponym.name().split('.')[0] for hyponym in synsets[0].hyponyms()]\n", " }\n", " \n", " return semantics\n", "\n", "# Map the semantic data between Chinese and English\n", "def map_semantics(chinese_word, english_word):\n", " cn_semantics = get_hownet_semantics(chinese_word)\n", " en_semantics = get_wordnet_semantics(english_word)\n", "\n", " if not cn_semantics or not en_semantics:\n", " return None\n", "\n", " # Perform mapping and save the result\n", " mapped_result = {\n", " \"chinese_word\": cn_semantics,\n", " \"english_word\": en_semantics\n", " }\n", "\n", " return mapped_result\n", "\n", "# Save the mapped result to a JSON file\n", "def save_mapped_result(chinese_word, english_word, output_file):\n", " mapped_result = map_semantics(chinese_word, english_word)\n", " \n", " if mapped_result:\n", " with open(output_file, 'w', encoding='utf-8') as f:\n", " json.dump(mapped_result, f, ensure_ascii=False, indent=4)\n", " print(f\"Mapped result saved to {output_file}\")\n", " else:\n", " print(f\"Unable to map words: {chinese_word} and {english_word}\")\n", "\n", "#Map \"苹果\" with \"apple\"\n", "save_mapped_result(\"苹果\", \"apple\", \"mapped_result.json\")\n", "\n", "#Map \"环绕\" with \"surround\"\n", "save_mapped_result(\"环绕\", \"surround\", \"mapped_result2.json\")\n" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Mapped result saved to mapped_result3.json\n", "Mapped result saved to mapped_result4.json\n" ] } ], "source": [ "import OpenHowNet\n", "import json\n", "import nltk\n", "from nltk.corpus import wordnet as wn\n", "\n", "# Create a HowNet object\n", "hownet_dict = OpenHowNet.HowNetDict()\n", "\n", "# Initialize HowNet sememe similarity calculation\n", "hownet_dict.initialize_sememe_similarity_calculation()\n", "\n", "# Extract semantic data from HowNet\n", "def get_hownet_semantics(word, language=\"zh\"):\n", " result_list = hownet_dict.get(word, language=language)\n", " if not result_list:\n", " return None\n", " \n", " # Extract definition, examples, and semantic relationships\n", " semantics = {\n", " \"word\": word,\n", " \"definition\": result_list[0].get(\"def\", \"\"),\n", " \"examples\": result_list[0].get(\"examples\", []),\n", " \"sememes\": result_list[0].get(\"sememes\", []),\n", " \"relations\": {\n", " \"synonyms\": [item[\"word\"] for item in result_list[0].get(\"syn\", [])],\n", " \"antonyms\": [item[\"word\"] for item in result_list[0].get(\"ant\", [])]\n", " }\n", " }\n", " \n", " return semantics\n", "\n", "# Extract semantic data from HowNet with enhanced robustness\n", "def get_hownet_semantics(word, language=\"zh\"):\n", " result_list = hownet_dict.get(word, language=language)\n", " if not result_list:\n", " return None\n", "\n", " # Get the first result with added robustness checks\n", " first_result = result_list[0] if result_list else {}\n", "\n", " semantics = {\n", " \"word\": word,\n", " \"definition\": first_result.get(\"def\", \"\"),\n", " \"examples\": first_result.get(\"examples\", []),\n", " \"sememes\": first_result.get(\"sememes\", []),\n", " \"relations\": {\n", " \"synonyms\": [item.get(\"word\", \"\") for item in first_result.get(\"syn\", [])],\n", " \"antonyms\": [item.get(\"word\", \"\") for item in first_result.get(\"ant\", [])]\n", " }\n", " }\n", " \n", " return semantics\n", "\n", "# Map semantic structures\n", "def map_semantics(chinese_word, english_word):\n", " cn_semantics = get_hownet_semantics(chinese_word)\n", " en_semantics = get_wordnet_semantics(english_word)\n", "\n", " if not cn_semantics or not en_semantics:\n", " return None\n", "\n", " # Map based on definitions and semantic relationships\n", " mapped_result = {\n", " \"chinese_word\": {\n", " \"word\": chinese_word,\n", " \"definition\": cn_semantics[\"definition\"],\n", " \"examples\": cn_semantics[\"examples\"],\n", " \"sememes\": cn_semantics[\"sememes\"],\n", " \"relations\": cn_semantics[\"relations\"]\n", " },\n", " \"english_word\": {\n", " \"word\": english_word,\n", " \"definition\": en_semantics[\"definition\"],\n", " \"examples\": en_semantics[\"examples\"],\n", " \"hypernyms\": en_semantics[\"hypernyms\"],\n", " \"hyponyms\": en_semantics[\"hyponyms\"],\n", " \"relations\": en_semantics.get(\"relations\", {})\n", " }\n", " }\n", "\n", " return mapped_result\n", "\n", "# Save the mapped result to a JSON file\n", "def save_mapped_result(chinese_word, english_word, output_file):\n", " mapped_result = map_semantics(chinese_word, english_word)\n", " \n", " if mapped_result:\n", " with open(output_file, 'w', encoding='utf-8') as f:\n", " json.dump(mapped_result, f, ensure_ascii=False, indent=4)\n", " print(f\"Mapped result saved to {output_file}\")\n", " else:\n", " print(f\"Unable to map words: {chinese_word} and {english_word}\")\n", "\n", "#Map \"苹果\" with \"apple\"\n", "save_mapped_result(\"苹果\", \"apple\", \"mapped_result3.json\")\n", "\n", "#Map \"环绕\" with \"surround\"\n", "save_mapped_result(\"环绕\", \"surround\", \"mapped_result4.json\")\n" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import OpenHowNet\n", "import json\n", "import nltk\n", "from nltk.corpus import wordnet as wn\n", "import networkx as nx\n", "import matplotlib.pyplot as plt\n", "\n", "# Extract semantic data from HowNet\n", "def get_hownet_semantics(word, language=\"zh\"):\n", " result_list = hownet_dict.get(word, language=language)\n", " if not result_list:\n", " return None\n", "\n", " first_result = result_list[0] if result_list else {}\n", "\n", " semantics = {\n", " \"word\": word,\n", " \"synonyms\": [item.get(\"word\", \"\") for item in first_result.get(\"syn\", [])],\n", " \"antonyms\": [item.get(\"word\", \"\") for item in first_result.get(\"ant\", [])],\n", " \"hypernyms\": [], # HowNet does not explicitly provide hypernym relations\n", " \"hyponyms\": []\n", " }\n", " \n", " return semantics\n", "\n", "# Extract semantic data from WordNet\n", "def get_wordnet_semantics(word):\n", " synsets = wn.synsets(word)\n", " if not synsets:\n", " return None\n", "\n", " semantics = {\n", " \"word\": word,\n", " \"synonyms\": [lemma.name() for lemma in synsets[0].lemmas()],\n", " \"antonyms\": [antonym.name() for lemma in synsets[0].lemmas() for antonym in lemma.antonyms()],\n", " \"hypernyms\": [hypernym.name().split('.')[0] for hypernym in synsets[0].hypernyms()],\n", " \"hyponyms\": [hyponym.name().split('.')[0] for hyponym in synsets[0].hyponyms()]\n", " }\n", " \n", " return semantics\n", "\n", "# Build a lexical semantic network\n", "def build_lexical_semantic_network(chinese_word, english_word):\n", " cn_semantics = get_hownet_semantics(chinese_word)\n", " en_semantics = get_wordnet_semantics(english_word)\n", " \n", " if not cn_semantics or not en_semantics:\n", " print(f\"Unable to map words: {chinese_word} and {english_word}\")\n", " return None\n", "\n", " # Create an undirected graph\n", " G = nx.Graph()\n", "\n", " # Add nodes\n", " G.add_node(cn_semantics[\"word\"], language=\"zh\")\n", " G.add_node(en_semantics[\"word\"], language=\"en\")\n", "\n", " # Add edges for Chinese semantic relations\n", " for synonym in cn_semantics[\"synonyms\"]:\n", " if synonym:\n", " G.add_node(synonym, language=\"zh\")\n", " G.add_edge(cn_semantics[\"word\"], synonym, relation=\"synonym\")\n", " \n", " for antonym in cn_semantics[\"antonyms\"]:\n", " if antonym:\n", " G.add_node(antonym, language=\"zh\")\n", " G.add_edge(cn_semantics[\"word\"], antonym, relation=\"antonym\")\n", "\n", " # Add edges for English semantic relations\n", " for synonym in en_semantics[\"synonyms\"]:\n", " if synonym:\n", " G.add_node(synonym, language=\"en\")\n", " G.add_edge(en_semantics[\"word\"], synonym, relation=\"synonym\")\n", " \n", " for antonym in en_semantics[\"antonyms\"]:\n", " if antonym:\n", " G.add_node(antonym, language=\"en\")\n", " G.add_edge(en_semantics[\"word\"], antonym, relation=\"antonym\")\n", " \n", " for hypernym in en_semantics[\"hypernyms\"]:\n", " G.add_node(hypernym, language=\"en\")\n", " G.add_edge(en_semantics[\"word\"], hypernym, relation=\"hypernym\")\n", " \n", " for hyponym in en_semantics[\"hyponyms\"]:\n", " G.add_node(hyponym, language=\"en\")\n", " G.add_edge(en_semantics[\"word\"], hyponym, relation=\"hyponym\")\n", "\n", " return G\n", "\n", "# Display the lexical semantic network\n", "def display_network(G):\n", " pos = nx.spring_layout(G)\n", " labels = nx.get_edge_attributes(G, 'relation')\n", " nx.draw(G, pos, with_labels=True, node_color='lightblue', font_size=10, node_size=2000)\n", " nx.draw_networkx_edge_labels(G, pos, edge_labels=labels, font_color='red')\n", " plt.show()\n", "\n", "# Example: Build and display the lexical semantic network for \"苹果\" and \"apple\"\n", "G = build_lexical_semantic_network(\"苹果\", \"apple\")\n", "if G:\n", " display_network(G)\n" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Successfully saved the semantic network for words 苹果 and apple!\n" ] } ], "source": [ "import json\n", "from nltk.corpus import wordnet as wn\n", "import networkx as nx\n", "import psycopg2\n", "\n", "\n", "# Build the lexical semantic network and convert it to JSON format\n", "def build_lexical_semantic_network_json(chinese_word, english_word):\n", " cn_semantics = get_hownet_semantics(chinese_word)\n", " en_semantics = get_wordnet_semantics(english_word)\n", " \n", " if not cn_semantics or not en_semantics:\n", " print(f\"Unable to map words: {chinese_word} and {english_word}\")\n", " return None\n", "\n", " # Build the graph and convert it to JSON structure\n", " G = nx.Graph()\n", "\n", " # Add nodes\n", " G.add_node(cn_semantics[\"word\"], language=\"zh\")\n", " G.add_node(en_semantics[\"word\"], language=\"en\")\n", "\n", " # Add edges for Chinese semantic relations\n", " for synonym in cn_semantics[\"synonyms\"]:\n", " if synonym:\n", " G.add_node(synonym, language=\"zh\")\n", " G.add_edge(cn_semantics[\"word\"], synonym, relation=\"synonym\")\n", " \n", " for antonym in cn_semantics[\"antonyms\"]:\n", " if antonym:\n", " G.add_node(antonym, language=\"zh\")\n", " G.add_edge(cn_semantics[\"word\"], antonym, relation=\"antonym\")\n", "\n", " # Add edges for English semantic relations\n", " for synonym in en_semantics[\"synonyms\"]:\n", " if synonym:\n", " G.add_node(synonym, language=\"en\")\n", " G.add_edge(en_semantics[\"word\"], synonym, relation=\"synonym\")\n", " \n", " for antonym in en_semantics[\"antonyms\"]:\n", " if antonym:\n", " G.add_node(antonym, language=\"en\")\n", " G.add_edge(en_semantics[\"word\"], antonym, relation=\"antonym\")\n", " \n", " for hypernym in en_semantics[\"hypernyms\"]:\n", " G.add_node(hypernym, language=\"en\")\n", " G.add_edge(en_semantics[\"word\"], hypernym, relation=\"hypernym\")\n", " \n", " for hyponym in en_semantics[\"hyponyms\"]:\n", " G.add_node(hyponym, language=\"en\")\n", " G.add_edge(en_semantics[\"word\"], hyponym, relation=\"hyponym\")\n", "\n", " # Convert the graph to JSON format\n", " network_data = nx.node_link_data(G)\n", " return json.dumps(network_data, ensure_ascii=False)\n", "\n", "# Extract semantic information from HowNet\n", "def get_hownet_semantics(word, language=\"zh\"):\n", " result_list = hownet_dict.get(word, language=language)\n", " if not result_list:\n", " return None\n", "\n", " first_result = result_list[0] if result_list else {}\n", " semantics = {\n", " \"word\": word,\n", " \"synonyms\": [item.get(\"word\", \"\") for item in first_result.get(\"syn\", [])],\n", " \"antonyms\": [item.get(\"word\", \"\") for item in first_result.get(\"ant\", [])],\n", " }\n", " return semantics\n", "\n", "# Extract semantic information from WordNet\n", "def get_wordnet_semantics(word):\n", " synsets = wn.synsets(word)\n", " if not synsets:\n", " return None\n", "\n", " semantics = {\n", " \"word\": word,\n", " \"synonyms\": [lemma.name() for lemma in synsets[0].lemmas()],\n", " \"antonyms\": [antonym.name() for lemma in synsets[0].lemmas() for antonym in lemma.antonyms()],\n", " \"hypernyms\": [hypernym.name().split('.')[0] for hypernym in synsets[0].hypernyms()],\n", " \"hyponyms\": [hyponym.name().split('.')[0] for hyponym in synsets[0].hyponyms()]\n", " }\n", " return semantics\n", "\n", "# Save the LSN to a PostgreSQL database\n", "def save_network_to_db(chinese_word, english_word, network_json):\n", " try:\n", " # Connect to the PostgreSQL database\n", " conn = psycopg2.connect(\n", " host=\"localhost\",\n", " database=\"mydatabase\",\n", " user=\"openpg\",\n", " password=\"openpgpwd\"\n", " )\n", " cur = conn.cursor()\n", "\n", " # Insert the LSN data into the database\n", " insert_query = \"\"\"\n", " INSERT INTO lexical_semantic_network (chinese_word, english_word, network_data)\n", " VALUES (%s, %s, %s)\n", " \"\"\"\n", " cur.execute(insert_query, (chinese_word, english_word, network_json))\n", " conn.commit()\n", "\n", " print(f\"Successfully saved the semantic network for words {chinese_word} and {english_word}!\")\n", "\n", " cur.close()\n", " conn.close()\n", " except Exception as e:\n", " print(f\"Error saving to the database: {e}\")\n", "\n", "# Build and save the lexical semantic network for \"苹果\" and \"apple\"\n", "network_json = build_lexical_semantic_network_json(\"苹果\", \"apple\")\n", "if network_json:\n", " save_network_to_db(\"苹果\", \"apple\", network_json)\n" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "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.11.5" } }, "nbformat": 4, "nbformat_minor": 2 }