{"id":3950,"date":"2023-11-04T23:13:57","date_gmt":"2023-11-04T23:13:57","guid":{"rendered":"http:\/\/localhost:10003\/how-to-use-llms-for-semantic-parsing-and-knowledge-graph-construction\/"},"modified":"2023-11-05T05:48:26","modified_gmt":"2023-11-05T05:48:26","slug":"how-to-use-llms-for-semantic-parsing-and-knowledge-graph-construction","status":"publish","type":"post","link":"http:\/\/localhost:10003\/how-to-use-llms-for-semantic-parsing-and-knowledge-graph-construction\/","title":{"rendered":"How to use LLMs for semantic parsing and knowledge graph construction"},"content":{"rendered":"<h1>How to Use Language Model to Construct Knowledge Graphs and Perform Semantic Parsing<\/h1>\n<p>In this tutorial, we will explore how to use Language Models (LMs) for semantic parsing and knowledge graph construction. Semantic parsing is the process of converting natural language into a structured representation that can be understood by machines. A knowledge graph is a way to represent information as a graph database, where entities are represented as nodes and relationships between entities are represented as edges.<\/p>\n<p>Language Models have revolutionized natural language processing tasks by learning contextual representations of words and sentences. We will use the Language Model called &#8220;Longformer&#8221; in this tutorial. The &#8220;Longformer&#8221; is a state-of-the-art Language Model that can handle long-range dependencies and has been pre-trained on a large corpus of text data.<\/p>\n<p>By the end of this tutorial, you will be able to use the Longformer Language Model for semantic parsing and knowledge graph construction. So, let&#8217;s get started!<\/p>\n<h2>Prerequisites<\/h2>\n<p>To follow along with this tutorial, you will need the following:<\/p>\n<ul>\n<li>Python 3.6 or above<\/li>\n<li><code>torch<\/code> library installed (<code>pip install torch<\/code>)<\/li>\n<li><code>transformers<\/code> library installed (<code>pip install transformers<\/code>)<\/li>\n<li><code>networkx<\/code> library installed (<code>pip install networkx<\/code>)<\/li>\n<li><code>matplotlib<\/code> library installed (<code>pip install matplotlib<\/code>)<\/li>\n<\/ul>\n<h2>Step 1: Installing the Required Libraries<\/h2>\n<p>First, we need to install the necessary libraries. Open your terminal or command prompt and execute the following commands to install the required libraries:<\/p>\n<pre><code class=\"language-shell\">pip install torch transformers networkx matplotlib\n<\/code><\/pre>\n<p>This will install the <code>torch<\/code> library, which provides a way to work with tensors and deep learning models, and the <code>transformers<\/code> library, which provides access to pre-trained Language Models like the Longformer. We also install the <code>networkx<\/code> and <code>matplotlib<\/code> libraries, which will be used for visualizing the knowledge graph.<\/p>\n<h2>Step 2: Importing the Required Libraries<\/h2>\n<p>Next, let&#8217;s import the required libraries into our Python script. Open your preferred Python IDE or text editor and create a new file, for example, <code>semantic_parsing.py<\/code>. Add the following imports at the beginning of the file:<\/p>\n<pre><code class=\"language-python\">import torch\nfrom transformers import LongformerTokenizer, LongformerModel\nimport networkx as nx\nimport matplotlib.pyplot as plt\n<\/code><\/pre>\n<p>We import the <code>torch<\/code> library, the <code>LongformerTokenizer<\/code> and <code>LongformerModel<\/code> classes from the <code>transformers<\/code> library, and the <code>networkx<\/code> and <code>matplotlib.pyplot<\/code> libraries for visualizing the knowledge graph.<\/p>\n<h2>Step 3: Setting up the Longformer<\/h2>\n<p>Now, let&#8217;s set up the Longformer Language Model. Add the following code to your <code>semantic_parsing.py<\/code> file:<\/p>\n<pre><code class=\"language-python\"># Load the pre-trained Longformer model and tokenizer\nmodel_name = \"allenai\/longformer-base-4096\"\ntokenizer = LongformerTokenizer.from_pretrained(model_name)\nmodel = LongformerModel.from_pretrained(model_name)\n\n# Set the device to GPU if available, otherwise use CPU\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\nmodel.to(device)\n\n# Set the model in evaluation mode\nmodel.eval()\n<\/code><\/pre>\n<p>In this code, we load the pre-trained Longformer model and tokenizer using the <code>longformer-base-4096<\/code> model. We also set the device to GPU if available, otherwise, we use the CPU. Finally, we set the model in evaluation mode.<\/p>\n<h2>Step 4: Parsing Input Text<\/h2>\n<p>Now, let&#8217;s define a helper function to parse the input text using the Longformer model. Add the following code to your <code>semantic_parsing.py<\/code> file:<\/p>\n<pre><code class=\"language-python\">def parse_text(input_text):\n    # Tokenize the input text\n    input_tokens = tokenizer.encode(input_text, add_special_tokens=False, return_tensors=\"pt\")\n    input_tokens = input_tokens.to(device)\n\n    # Generate the output embeddings\n    with torch.no_grad():\n        output = model(input_tokens)[0]\n\n    # Convert the output tensor to numpy array\n    output = output.detach().cpu().numpy()\n\n    return output\n<\/code><\/pre>\n<p>In this code, we tokenize the input text using the Longformer tokenizer. We then convert the tokenized input into tensors and move it to the device (GPU or CPU) where the Longformer model is located. We generate the output embeddings by passing the input tokens through the Longformer model and extract the output tensor. Finally, we convert the output tensor to a numpy array and return it.<\/p>\n<h2>Step 5: Constructing the Knowledge Graph<\/h2>\n<p>Let&#8217;s now define a function to construct the knowledge graph from the output of the Longformer model. Add the following code to your <code>semantic_parsing.py<\/code> file:<\/p>\n<pre><code class=\"language-python\">def construct_graph(output):\n    # Create an empty graph\n    graph = nx.Graph()\n\n    # Add nodes to the graph\n    for i, embedding in enumerate(output):\n        graph.add_node(i, embedding=embedding)\n\n    # Calculate the similarity between embeddings\n    for i in range(len(output)):\n        for j in range(i + 1, len(output)):\n            similarity = cosine_similarity(output[i], output[j])\n            graph.add_edge(i, j, weight=similarity)\n\n    return graph\n<\/code><\/pre>\n<p>In this code, we create an empty graph using the <code>nx.Graph()<\/code> function from the Networkx library. We then iterate over the output embeddings and add nodes to the graph using the <code>graph.add_node()<\/code> function. Next, we calculate the similarity between the embeddings using a similarity metric such as cosine similarity. Finally, we add edges to the graph with the similarity as the weight using the <code>graph.add_edge()<\/code> function.<\/p>\n<h2>Step 6: Visualizing the Knowledge Graph<\/h2>\n<p>Finally, let&#8217;s define a function to visualize the constructed knowledge graph. Add the following code to your <code>semantic_parsing.py<\/code> file:<\/p>\n<pre><code class=\"language-python\">def visualize_graph(graph):\n    # Draw the graph with node labels and edge weights\n    pos = nx.spring_layout(graph)\n    labels = nx.get_edge_attributes(graph, \"weight\")\n    nx.draw(graph, pos, with_labels=True)\n    nx.draw_networkx_edge_labels(graph, pos, edge_labels=labels)\n    plt.show()\n<\/code><\/pre>\n<p>In this code, we use the <code>nx.spring_layout()<\/code> function to calculate the positions of the graph nodes. We use the <code>nx.draw()<\/code> function to draw the nodes and edges of the graph. We also use the <code>nx.get_edge_attributes()<\/code> function to get the edge weights and pass them to the <code>nx.draw_networkx_edge_labels()<\/code> function to label the edges with their weights. Finally, we use the <code>plt.show()<\/code> function to display the graph.<\/p>\n<h2>Step 7: Putting it All Together<\/h2>\n<p>Now, let&#8217;s put all the previously defined functions together and test our semantic parsing and knowledge graph construction pipeline. Add the following code to your <code>semantic_parsing.py<\/code> file:<\/p>\n<pre><code class=\"language-python\">def main():\n    # Example input text\n    input_text = \"Apple Inc. is an American multinational technology company headquartered in Cupertino, California. It designs, manufactures, and markets consumer electronics, computer software, and online services.\"\n\n    # Parse the input text\n    output = parse_text(input_text)\n\n    # Construct the knowledge graph\n    graph = construct_graph(output)\n\n    # Visualize the knowledge graph\n    visualize_graph(graph)\n\n\nif __name__ == \"__main__\":\n    main()\n<\/code><\/pre>\n<p>In this code, we define the <code>main()<\/code> function, which is the entry point of our script. We provide an example input text and pass it to the <code>parse_text()<\/code> function to obtain the output embeddings. We then pass the output embeddings to the <code>construct_graph()<\/code> function to construct the knowledge graph. Finally, we visualize the knowledge graph using the <code>visualize_graph()<\/code> function.<\/p>\n<h2>Step 8: Running the Script<\/h2>\n<p>To run the script, open your terminal or command prompt, navigate to the directory where your <code>semantic_parsing.py<\/code> file is located, and execute the following command:<\/p>\n<pre><code class=\"language-shell\">python semantic_parsing.py\n<\/code><\/pre>\n<p>This will execute the script and display the knowledge graph in a separate window.<\/p>\n<h2>Conclusion<\/h2>\n<p>In this tutorial, we have explored how to use Language Models (LMs) for semantic parsing and knowledge graph construction. We used the Longformer Language Model and the Networkx library to parse input text, construct a knowledge graph, and visualize the results. You can now apply this knowledge to various natural language processing tasks that require semantic parsing and knowledge graph construction.<\/p>\n<p>Remember to experiment with different input texts, change the hyperparameters, and explore other pre-trained Language Models to improve the performance of your semantic parsing and knowledge graph construction pipeline. Happy coding!<\/p>\n","protected":false},"excerpt":{"rendered":"<p>How to Use Language Model to Construct Knowledge Graphs and Perform Semantic Parsing In this tutorial, we will explore how to use Language Models (LMs) for semantic parsing and knowledge graph construction. Semantic parsing is the process of converting natural language into a structured representation that can be understood by <a href=\"http:\/\/localhost:10003\/how-to-use-llms-for-semantic-parsing-and-knowledge-graph-construction\/\" class=\"btn btn-link continue-link\">Continue Reading<\/a><\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_import_markdown_pro_load_document_selector":0,"_import_markdown_pro_submit_text_textarea":"","footnotes":""},"categories":[1],"tags":[207,39,230,519,518,245,41,520,40,206,517,521],"yoast_head":"<!-- This site is optimized with the Yoast SEO Premium plugin v21.5 (Yoast SEO v21.5) - https:\/\/yoast.com\/wordpress\/plugins\/seo\/ -->\n<title>How to use LLMs for semantic parsing and knowledge graph construction - Pantherax Blogs<\/title>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"http:\/\/localhost:10003\/how-to-use-llms-for-semantic-parsing-and-knowledge-graph-construction\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"How to use LLMs for semantic parsing and knowledge graph construction\" \/>\n<meta property=\"og:description\" content=\"How to Use Language Model to Construct Knowledge Graphs and Perform Semantic Parsing In this tutorial, we will explore how to use Language Models (LMs) for semantic parsing and knowledge graph construction. Semantic parsing is the process of converting natural language into a structured representation that can be understood by Continue Reading\" \/>\n<meta property=\"og:url\" content=\"http:\/\/localhost:10003\/how-to-use-llms-for-semantic-parsing-and-knowledge-graph-construction\/\" \/>\n<meta property=\"og:site_name\" content=\"Pantherax Blogs\" \/>\n<meta property=\"article:published_time\" content=\"2023-11-04T23:13:57+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-11-05T05:48:26+00:00\" \/>\n<meta name=\"author\" content=\"Panther\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Panther\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"6 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\n\t    \"@context\": \"https:\/\/schema.org\",\n\t    \"@graph\": [\n\t        {\n\t            \"@type\": \"Article\",\n\t            \"@id\": \"http:\/\/localhost:10003\/how-to-use-llms-for-semantic-parsing-and-knowledge-graph-construction\/#article\",\n\t            \"isPartOf\": {\n\t                \"@id\": \"http:\/\/localhost:10003\/how-to-use-llms-for-semantic-parsing-and-knowledge-graph-construction\/\"\n\t            },\n\t            \"author\": {\n\t                \"name\": \"Panther\",\n\t                \"@id\": \"http:\/\/localhost:10003\/#\/schema\/person\/b63d816f4964b163e53cbbcffaa0f3d7\"\n\t            },\n\t            \"headline\": \"How to use LLMs for semantic parsing and knowledge graph construction\",\n\t            \"datePublished\": \"2023-11-04T23:13:57+00:00\",\n\t            \"dateModified\": \"2023-11-05T05:48:26+00:00\",\n\t            \"mainEntityOfPage\": {\n\t                \"@id\": \"http:\/\/localhost:10003\/how-to-use-llms-for-semantic-parsing-and-knowledge-graph-construction\/\"\n\t            },\n\t            \"wordCount\": 874,\n\t            \"publisher\": {\n\t                \"@id\": \"http:\/\/localhost:10003\/#organization\"\n\t            },\n\t            \"keywords\": [\n\t                \"\\\"AI\\\"]\",\n\t                \"\\\"Artificial Intelligence\\\"\",\n\t                \"\\\"deep learning\\\"]\",\n\t                \"\\\"how to use\\\"\",\n\t                \"\\\"knowledge graph construction\\\"\",\n\t                \"\\\"LLMs\\\"\",\n\t                \"\\\"Machine Learning\\\"\",\n\t                \"\\\"ML\\\"\",\n\t                \"\\\"Natural Language Processing\\\"\",\n\t                \"\\\"NLP\\\"\",\n\t                \"\\\"semantic parsing\\\"\",\n\t                \"\\\"transformers\\\"\"\n\t            ],\n\t            \"inLanguage\": \"en-US\"\n\t        },\n\t        {\n\t            \"@type\": \"WebPage\",\n\t            \"@id\": \"http:\/\/localhost:10003\/how-to-use-llms-for-semantic-parsing-and-knowledge-graph-construction\/\",\n\t            \"url\": \"http:\/\/localhost:10003\/how-to-use-llms-for-semantic-parsing-and-knowledge-graph-construction\/\",\n\t            \"name\": \"How to use LLMs for semantic parsing and knowledge graph construction - Pantherax Blogs\",\n\t            \"isPartOf\": {\n\t                \"@id\": \"http:\/\/localhost:10003\/#website\"\n\t            },\n\t            \"datePublished\": \"2023-11-04T23:13:57+00:00\",\n\t            \"dateModified\": \"2023-11-05T05:48:26+00:00\",\n\t            \"breadcrumb\": {\n\t                \"@id\": \"http:\/\/localhost:10003\/how-to-use-llms-for-semantic-parsing-and-knowledge-graph-construction\/#breadcrumb\"\n\t            },\n\t            \"inLanguage\": \"en-US\",\n\t            \"potentialAction\": [\n\t                {\n\t                    \"@type\": \"ReadAction\",\n\t                    \"target\": [\n\t                        \"http:\/\/localhost:10003\/how-to-use-llms-for-semantic-parsing-and-knowledge-graph-construction\/\"\n\t                    ]\n\t                }\n\t            ]\n\t        },\n\t        {\n\t            \"@type\": \"BreadcrumbList\",\n\t            \"@id\": \"http:\/\/localhost:10003\/how-to-use-llms-for-semantic-parsing-and-knowledge-graph-construction\/#breadcrumb\",\n\t            \"itemListElement\": [\n\t                {\n\t                    \"@type\": \"ListItem\",\n\t                    \"position\": 1,\n\t                    \"name\": \"Home\",\n\t                    \"item\": \"http:\/\/localhost:10003\/\"\n\t                },\n\t                {\n\t                    \"@type\": \"ListItem\",\n\t                    \"position\": 2,\n\t                    \"name\": \"How to use LLMs for semantic parsing and knowledge graph construction\"\n\t                }\n\t            ]\n\t        },\n\t        {\n\t            \"@type\": \"WebSite\",\n\t            \"@id\": \"http:\/\/localhost:10003\/#website\",\n\t            \"url\": \"http:\/\/localhost:10003\/\",\n\t            \"name\": \"Pantherax Blogs\",\n\t            \"description\": \"\",\n\t            \"publisher\": {\n\t                \"@id\": \"http:\/\/localhost:10003\/#organization\"\n\t            },\n\t            \"potentialAction\": [\n\t                {\n\t                    \"@type\": \"SearchAction\",\n\t                    \"target\": {\n\t                        \"@type\": \"EntryPoint\",\n\t                        \"urlTemplate\": \"http:\/\/localhost:10003\/?s={search_term_string}\"\n\t                    },\n\t                    \"query-input\": \"required name=search_term_string\"\n\t                }\n\t            ],\n\t            \"inLanguage\": \"en-US\"\n\t        },\n\t        {\n\t            \"@type\": \"Organization\",\n\t            \"@id\": \"http:\/\/localhost:10003\/#organization\",\n\t            \"name\": \"Pantherax Blogs\",\n\t            \"url\": \"http:\/\/localhost:10003\/\",\n\t            \"logo\": {\n\t                \"@type\": \"ImageObject\",\n\t                \"inLanguage\": \"en-US\",\n\t                \"@id\": \"http:\/\/localhost:10003\/#\/schema\/logo\/image\/\",\n\t                \"url\": \"http:\/\/localhost:10003\/wp-content\/uploads\/2023\/11\/cropped-9e7721cb-2d62-4f72-ab7f-7d1d8db89226.jpeg\",\n\t                \"contentUrl\": \"http:\/\/localhost:10003\/wp-content\/uploads\/2023\/11\/cropped-9e7721cb-2d62-4f72-ab7f-7d1d8db89226.jpeg\",\n\t                \"width\": 1024,\n\t                \"height\": 1024,\n\t                \"caption\": \"Pantherax Blogs\"\n\t            },\n\t            \"image\": {\n\t                \"@id\": \"http:\/\/localhost:10003\/#\/schema\/logo\/image\/\"\n\t            }\n\t        },\n\t        {\n\t            \"@type\": \"Person\",\n\t            \"@id\": \"http:\/\/localhost:10003\/#\/schema\/person\/b63d816f4964b163e53cbbcffaa0f3d7\",\n\t            \"name\": \"Panther\",\n\t            \"image\": {\n\t                \"@type\": \"ImageObject\",\n\t                \"inLanguage\": \"en-US\",\n\t                \"@id\": \"http:\/\/localhost:10003\/#\/schema\/person\/image\/\",\n\t                \"url\": \"http:\/\/2.gravatar.com\/avatar\/b8c0eda5a49f8f31ec32d0a0f9d6f838?s=96&d=mm&r=g\",\n\t                \"contentUrl\": \"http:\/\/2.gravatar.com\/avatar\/b8c0eda5a49f8f31ec32d0a0f9d6f838?s=96&d=mm&r=g\",\n\t                \"caption\": \"Panther\"\n\t            },\n\t            \"sameAs\": [\n\t                \"http:\/\/localhost:10003\"\n\t            ],\n\t            \"url\": \"http:\/\/localhost:10003\/author\/pepethefrog\/\"\n\t        }\n\t    ]\n\t}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"How to use LLMs for semantic parsing and knowledge graph construction - Pantherax Blogs","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"http:\/\/localhost:10003\/how-to-use-llms-for-semantic-parsing-and-knowledge-graph-construction\/","og_locale":"en_US","og_type":"article","og_title":"How to use LLMs for semantic parsing and knowledge graph construction","og_description":"How to Use Language Model to Construct Knowledge Graphs and Perform Semantic Parsing In this tutorial, we will explore how to use Language Models (LMs) for semantic parsing and knowledge graph construction. Semantic parsing is the process of converting natural language into a structured representation that can be understood by Continue Reading","og_url":"http:\/\/localhost:10003\/how-to-use-llms-for-semantic-parsing-and-knowledge-graph-construction\/","og_site_name":"Pantherax Blogs","article_published_time":"2023-11-04T23:13:57+00:00","article_modified_time":"2023-11-05T05:48:26+00:00","author":"Panther","twitter_card":"summary_large_image","twitter_misc":{"Written by":"Panther","Est. reading time":"6 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"http:\/\/localhost:10003\/how-to-use-llms-for-semantic-parsing-and-knowledge-graph-construction\/#article","isPartOf":{"@id":"http:\/\/localhost:10003\/how-to-use-llms-for-semantic-parsing-and-knowledge-graph-construction\/"},"author":{"name":"Panther","@id":"http:\/\/localhost:10003\/#\/schema\/person\/b63d816f4964b163e53cbbcffaa0f3d7"},"headline":"How to use LLMs for semantic parsing and knowledge graph construction","datePublished":"2023-11-04T23:13:57+00:00","dateModified":"2023-11-05T05:48:26+00:00","mainEntityOfPage":{"@id":"http:\/\/localhost:10003\/how-to-use-llms-for-semantic-parsing-and-knowledge-graph-construction\/"},"wordCount":874,"publisher":{"@id":"http:\/\/localhost:10003\/#organization"},"keywords":["\"AI\"]","\"Artificial Intelligence\"","\"deep learning\"]","\"how to use\"","\"knowledge graph construction\"","\"LLMs\"","\"Machine Learning\"","\"ML\"","\"Natural Language Processing\"","\"NLP\"","\"semantic parsing\"","\"transformers\""],"inLanguage":"en-US"},{"@type":"WebPage","@id":"http:\/\/localhost:10003\/how-to-use-llms-for-semantic-parsing-and-knowledge-graph-construction\/","url":"http:\/\/localhost:10003\/how-to-use-llms-for-semantic-parsing-and-knowledge-graph-construction\/","name":"How to use LLMs for semantic parsing and knowledge graph construction - Pantherax Blogs","isPartOf":{"@id":"http:\/\/localhost:10003\/#website"},"datePublished":"2023-11-04T23:13:57+00:00","dateModified":"2023-11-05T05:48:26+00:00","breadcrumb":{"@id":"http:\/\/localhost:10003\/how-to-use-llms-for-semantic-parsing-and-knowledge-graph-construction\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["http:\/\/localhost:10003\/how-to-use-llms-for-semantic-parsing-and-knowledge-graph-construction\/"]}]},{"@type":"BreadcrumbList","@id":"http:\/\/localhost:10003\/how-to-use-llms-for-semantic-parsing-and-knowledge-graph-construction\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"http:\/\/localhost:10003\/"},{"@type":"ListItem","position":2,"name":"How to use LLMs for semantic parsing and knowledge graph construction"}]},{"@type":"WebSite","@id":"http:\/\/localhost:10003\/#website","url":"http:\/\/localhost:10003\/","name":"Pantherax Blogs","description":"","publisher":{"@id":"http:\/\/localhost:10003\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"http:\/\/localhost:10003\/?s={search_term_string}"},"query-input":"required name=search_term_string"}],"inLanguage":"en-US"},{"@type":"Organization","@id":"http:\/\/localhost:10003\/#organization","name":"Pantherax Blogs","url":"http:\/\/localhost:10003\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"http:\/\/localhost:10003\/#\/schema\/logo\/image\/","url":"http:\/\/localhost:10003\/wp-content\/uploads\/2023\/11\/cropped-9e7721cb-2d62-4f72-ab7f-7d1d8db89226.jpeg","contentUrl":"http:\/\/localhost:10003\/wp-content\/uploads\/2023\/11\/cropped-9e7721cb-2d62-4f72-ab7f-7d1d8db89226.jpeg","width":1024,"height":1024,"caption":"Pantherax Blogs"},"image":{"@id":"http:\/\/localhost:10003\/#\/schema\/logo\/image\/"}},{"@type":"Person","@id":"http:\/\/localhost:10003\/#\/schema\/person\/b63d816f4964b163e53cbbcffaa0f3d7","name":"Panther","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"http:\/\/localhost:10003\/#\/schema\/person\/image\/","url":"http:\/\/2.gravatar.com\/avatar\/b8c0eda5a49f8f31ec32d0a0f9d6f838?s=96&d=mm&r=g","contentUrl":"http:\/\/2.gravatar.com\/avatar\/b8c0eda5a49f8f31ec32d0a0f9d6f838?s=96&d=mm&r=g","caption":"Panther"},"sameAs":["http:\/\/localhost:10003"],"url":"http:\/\/localhost:10003\/author\/pepethefrog\/"}]}},"jetpack_sharing_enabled":true,"jetpack_featured_media_url":"","_links":{"self":[{"href":"http:\/\/localhost:10003\/wp-json\/wp\/v2\/posts\/3950"}],"collection":[{"href":"http:\/\/localhost:10003\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"http:\/\/localhost:10003\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"http:\/\/localhost:10003\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"http:\/\/localhost:10003\/wp-json\/wp\/v2\/comments?post=3950"}],"version-history":[{"count":1,"href":"http:\/\/localhost:10003\/wp-json\/wp\/v2\/posts\/3950\/revisions"}],"predecessor-version":[{"id":4586,"href":"http:\/\/localhost:10003\/wp-json\/wp\/v2\/posts\/3950\/revisions\/4586"}],"wp:attachment":[{"href":"http:\/\/localhost:10003\/wp-json\/wp\/v2\/media?parent=3950"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"http:\/\/localhost:10003\/wp-json\/wp\/v2\/categories?post=3950"},{"taxonomy":"post_tag","embeddable":true,"href":"http:\/\/localhost:10003\/wp-json\/wp\/v2\/tags?post=3950"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}