Method Count: The number of methods associated with a class. This helps the GNN understand the size and complexity of a class. Description Length: The length of the class or method description. A longer description might indicate more complex entities, giving the GNN a hint about the entity’s importance. Is Class / Is Method: Binary flags that tell whether the node represents a class (1 if true) or a method (1 if true). Node Degree: This represents how many connections (edges) a node has. A class that is inherited by several other classes or calls multiple methods would have a higher degree. Edge Features: Relationship Type: Inheritance (0): Edges between parent and child classes in the inheritance hierarchy. Method Call/Definition (1): Edges representing method calls or definitions within or between classes.

In the world of Natural Language Processing (NLP), understanding and manipulating search queries is crucial for enhancing search performance. One of the most powerful techniques in this domain is query rewriting. This blog provides an in-depth exploration of query rewriting, focusing on how it enhances search recall and precision. We'll use a single e-commerce example throughout to illustrate these concepts and include Python code snippets to demonstrate their implementation. Why Do We Need Query Rewriting? Query rewriting is essential because it helps search engines better represent the searcher's intent, thereby improving the quality of search results. This is particularly important in e-commerce, where precise and relevant search results can significantly impact the user experience and sales. Real-Life Use Case: E-Commerce Imagine you're running an e-commerce site that sells various electronic gadgets. A user searches for "wireless earbuds." The challenge is to ensure that the search engine retrieves all relevant products, even if the user's query doesn't exactly match the product descriptions in the database. Query rewriting techniques like query expansion and query relaxation can help achieve this goal. Increasing Recall Recall refers to the ability of a search system to retrieve all relevant documents. Increasing recall is crucial when the initial query returns few or no results.

In the realm of Natural Language Processing (NLP), understanding how words relate to each other is crucial for various applications like search engines, chatbots, and text analysis. One common challenge is dealing with different forms of words that essentially mean the same thing. Let's explore two essential techniques that help address this issue: stemming and lemmatization. What are Stemming and Lemmatization? Stemming involves reducing words to their root form by chopping off prefixes or suffixes. It aims to achieve this by using simple rules without understanding the context of the word. For example, words like "running" and "runner" would both be reduced to "run." This helps in capturing the essence of words and increasing the chances of matching similar words during searches or analysis. Lemmatization, on the other hand, goes beyond just chopping off prefixes or suffixes. It considers the context and meaning of the word along with its morphology. Lemmatization uses dictionaries and morphological analysis to convert words into their base or dictionary form. For instance, "better" would be lemmatized to "good," ensuring accuracy in analysis by understanding the intended meaning. Why are They Important? In NLP, the same concept can be expressed in various forms. For instance, "run," "running," and "ran" all convey the action of moving swiftly on foot. By applying stemming or lemmatization, NLP systems can treat these variations as the same word, improving search accuracy and text analysis.

In the world of modern search engines, spelling correction is not just a feature but a critical component that ensures users find relevant information even when they make mistakes in their queries. Studies suggest that between 10% to 15% of search queries contain spelling errors, underscoring the importance of robust correction mechanisms to maintain a seamless user experience. The Importance of Spelling Correction Imagine searching for "furniture" but accidentally typing "furnitue". Without effective spelling correction, the search engine might fail to retrieve relevant results, frustrating the user and potentially leading to a poor search experience. Therefore, implementing a reliable spelling correction system is paramount for any search engine aiming to deliver accurate results consistently. Leveraging Existing Solutions Developing a spelling correction system from scratch is a daunting task that requires significant expertise and resources. Fortunately, there are robust off-the-shelf solutions available, such as Aspell or Hunspell. These tools offer customizable options that can be tailored to suit different needs and linguistic contexts, making them accessible and efficient choices for integrating spelling correction into search engines and other applications. Understanding Spelling Correction Components To understand how spelling correction works, it's essential to delve into its key components and processes:

Search engines operate on the fundamental unit of characters within queries. Despite their apparent simplicity, characters carry nuances that are crucial for robust search functionality. This article delves into character filtering techniques, essential for transforming text at its core, thereby facilitating accurate query processing. Unicode Normalization Modern systems universally support Unicode, a global standard for text encoding. Unicode normalization standardizes character representations, crucial for recognizing equivalent forms. There are several normalization forms: NFD (Normalization Form Canonical Decomposition): Decomposes characters into canonical equivalents, arranging combining characters in a specific order. NFC (Normalization Form Canonical Composition): Decomposes and then recomposes characters. NFKD and NFKC are variants that use compatibility forms for more stringent standardization. For search applications, a decomposition-based normalization like NFD or NFKD is preferred. This simplifies subsequent operations such as accent removal, which is straightforward post-decomposition. Tools like Java, Python, Apache Lucene, and Elasticsearch support Unicode normalization, ensuring compatibility across platforms.

When you type something into a search engine, have you ever wondered how it knows what language you're using? This is where language identification comes into play. It's like a translator that figures out which language you're speaking, but for search engines. History and Evolution Language identification has been around since the 1970s. Back then, researchers used statistical tricks to analyze texts and figure out languages based on things like how often certain letters or sounds appeared. It was like trying to guess a puzzle from a few scattered pieces. Challenges with Short Queries Imagine you're a detective trying to solve a case with just a few clues. That's what it's like for search engines with short queries. Studies have shown that it's tough to accurately guess the language of a search query if it's fewer than 50 characters long. There's just not enough information to work with. Innovations Using Search Data Now, let's talk about a clever trick some researchers used. They noticed that people often click on search results that are in the same language as their query. So, instead of just guessing from the query itself, they looked at which results people clicked on. It's like knowing someone's favorite music by looking at their playlists.

Topic Introduction Describe CGN Working Topic So far we have covered various network which based on graph data but still we have left so much topic. In this tutorial we will talk about curvature graph network which bassically tells us the structural information of our networks. we have seen GCN which tells us to degree information by using neighborhoods and aggregiation principle but not tells about how structurally pair node conected, which give more information about data. We propose a novel network architecture that incorporates advanced graph structural information, specifically, discrete graph curvature, which measures how the neighborhoods of a pair of nodes are structurally related. The curvature of an edge (x, y) is defined by comparing the distance taken to travel from neighbors of x to neighbors of y, with the length of edge (x, y).. It is a much more descriptive structural measure compared to previously ones that only focus on node specific attributes or limited graph topological information such as degree. Introduction

In the today world of digital information, search engines stand as our trusty guides, leading us through the labyrinth of online content. However, the true magic lies not just in the results they deliver, but in their ability to understand and cater to our needs. This is where the concept of query understanding steps into the spotlight, reshaping the way we interact with search engines. In this extensive exploration, we'll dive deep into the realm of query understanding, unraveling its mysteries and showcasing its real-life applications with vivid examples. Demystifying Query Understanding: A Closer Look At its heart, query understanding revolves around deciphering the intent behind user queries, transforming strings of text into meaningful insights. Let's consider a real-life example to illustrate this concept. Imagine you're planning a trip to Italy and want to explore the culinary delights of Florence. You might enter a query like "best restaurants in Florence" into a search engine. Behind the scenes, query understanding processes this input, grasping your desire to discover top dining spots in a specific location. Example: ​​​​Tokenization: Break the query into individual words: ["best", "restaurants", "in", "Florence"]. ​​​​Normalization: Convert the query to lowercase and remove punctuation: "best restaurants in florence".

In the realm of data management and retrieval, text analysis stands as a crucial pillar, enabling efficient search and retrieval of textual information. At the forefront of text analysis tools lies Elasticsearch, a robust search and analytics engine renowned for its powerful capabilities in handling textual data. In this comprehensive guide, we'll embark on a journey to unlock the full potential of text analysis in Elasticsearch, exploring its components, real-world applications, advantages, and potential drawbacks. Understanding Text Analysis in Elasticsearch Text analysis, often referred to simply as analysis in the context of Elasticsearch, is the process of preprocessing textual data before indexing it into the Elasticsearch engine. The primary objective of text analysis is to break down raw text into smaller, searchable units called tokens, thereby facilitating rapid and accurate searching. Using the Analyze API We can use the Analyze API to check how specific character filters, tokenizers, token filters, or analyzers handle text inputs. In this example, we'll use the sentence from the previous example and go through each step of the standard analyzer. The purpose is to demonstrate how to use the Analyze API for debugging and gaining a better understanding of the analysis process for a given piece of text. Since the standard analyzer doesn’t use a character filter, the first step is tokenization using the standard tokenizer.

The inverted index is a fundamental concept in Elasticsearch that plays a crucial role in enabling efficient and fast full-text searches. Let's delve into what the inverted index is, why we use it, its advantages and disadvantages, real-world use cases, any alternatives, and include coding input and output examples. What is the Inverted Index? The purpose of an inverted index is to store text in a structure that allows for efficient full-text searches. It consists of all the unique terms that appear in any document covered by the index. For each term, the list of documents in which the term appears is stored. Essentially, an inverted index maps terms to the documents containing those terms. Why Do We Use the Inverted Index? Efficient Searching: Inverted indices enable fast and efficient full-text searches by organizing terms and their associated documents. Space Efficiency: Inverted indices are space-efficient compared to storing entire documents, as they only store unique terms and their document references. Scalability: They scale well with large datasets, as they facilitate quick retrieval of relevant documents.

Elasticsearch is a powerful distributed search and analytics engine, widely used for real-time indexing, search, and analysis of data. In this guide, we'll delve into various Elasticsearch operations, covering everything from creating and deleting indices to advanced topics like batch processing and optimistic concurrency control. Along the way, we'll provide detailed coding examples to help you grasp each concept effectively. Creating & Deleting Indices Creating an index in Elasticsearch is the first step towards storing your data. Indices are logical namespaces that map to physical data storage. Here's how you can create and delete indices using Elasticsearch's RESTful API: # Creating an index PUT /shopping { "settings": { "number_of_shards": 1,

Elasticsearch is a powerful and versatile tool for managing and querying large volumes of data. In this blog post, we'll delve into the concept of replication within Elasticsearch. Replication plays a crucial role in ensuring data availability and fault tolerance within an Elasticsearch cluster. What is Replication? Before diving into replication, let's quickly recap what sharding is. Sharding involves dividing data into smaller subsets, or shards, which are distributed across multiple nodes in a cluster. Each shard contains a portion of the indexed data. Now, imagine a scenario where one of the nodes in your Elasticsearch cluster experiences a hardware failure, such as a disk malfunction. In such cases, the data stored on that node would be lost, potentially leading to data unavailability or even loss. This is where replication comes into play. Replication in Elasticsearch involves creating copies of each shard, known as replica shards, and distributing them across different nodes within the cluster. These replica shards serve as backups, ensuring that even if a node fails, the data remains accessible from other nodes. How Replication Works

In our previous discussions, we've delved into the architecture of Elasticsearch, particularly how it operates within a cluster of nodes. Now, let's dive deeper into one of the core concepts that enables Elasticsearch to scale effectively: sharding. What is Sharding? Imagine you have a massive amount of data to store, but no single node within your Elasticsearch cluster has enough space to accommodate it all. Sharding comes to the rescue. Sharding involves dividing an index into smaller pieces, each known as a shard. This process allows Elasticsearch to distribute and manage data across multiple nodes efficiently. Real-Life Example: Think of sharding as breaking a big task into smaller, manageable pieces. For instance, suppose you have a large group project to complete. Instead of working on the entire project alone, you divide it among team members. Each member handles their assigned part independently, making the overall project easier to manage.

Elasticsearch is a powerful search engine that allows you to analyze and search large volumes of data quickly and in real-time. To interact with Elasticsearch, developers often use tools like Kibana Console and cURL. In this tutorial, we'll explore how to run queries using these tools, focusing on cURL for more flexibility and control. Introduction to Kibana Console Kibana Console is a user-friendly tool provided within the Kibana dashboard that simplifies the process of running queries against an Elasticsearch cluster. Here's why it's advantageous: Formatted Responses: Kibana Console formats responses for easy readability. Auto-completion: It provides auto-completion, making it easier to construct queries. Handling Headers: It handles setting the correct Content-Type header automatically. Throughout this course, we'll predominantly use Kibana Console due to its convenience. However, understanding how to use cURL is essential, and we'll delve into that next.

Introduction In this post, we will explore an Elasticsearch cluster using Kibana's Console tool. We'll learn how to send requests to Elasticsearch and interpret the responses. This is a beginner-friendly guide, so don't worry if you're new to these tools. What is a REST API? A REST API (Representational State Transfer Application Programming Interface) is a way to interact with web services using HTTP requests. It follows a set of constraints that make it easy to build scalable and efficient web services. The main HTTP verbs used in REST APIs are: GET: Retrieve data from the server. POST: Send data to the server to create a new resource. PUT: Update an existing resource on the server. DELETE: Remove a resource from the server.

Welcome to this blog where we'll discuss the architecture of Elasticsearch and Kibana. If you're new to these tools, don't worry—we'll explain everything in simple terms with plenty of examples. What is Elasticsearch? Elasticsearch is a powerful search and analytics engine. Once installed, it starts up an instance called a node. A node is where data is stored. You can have multiple nodes to store large amounts of data. For example, if you need to store many terabytes of data, you can run multiple nodes, each storing part of the data. Nodes and Machines A node is not the same as a machine. You can run several nodes on a single machine. This is useful for development where you might want to test how multiple nodes work together without needing multiple machines. However, in a production environment, it’s best to have each node on a separate machine, virtual machine, or within a container to ensure stability and performance. Clusters: Bringing Nodes Together Nodes don't work alone—they belong to a cluster. A cluster is a group of nodes that together store all your data. You usually only need one cluster, but you can have more if needed. For instance, you might have one cluster for an e-commerce application and another for monitoring application performance (Application Performance Management or APM).

Motivation What is Hyperbolic Space What is Hyperbolic Graph Convolutional Neural Networks(HGCNN) Mehtod to Implement of HGCNN HYPERGCN architecture Final Key Point Advantages of HGCNN Motivation The motivation of HGCMNN all about comes from GCN model. when we have been implepenting GCN, we are perform node embedding operation that reduce the size of input graph, and with the use of it we can create feture vector. Graph convolutional neural networks (GCNs) map nodes in a graph to Euclidean embeddings, which have been shown to incur a large distortion when embedding real-world graphs with scale-free or hierarchical structure. To reduce the distortion researchers has found a way where embedding has less distortion. Hyperbolic geometry offers an exciting alternative, as it enables embeddings with much smaller distortion

Deepak Yadav Description Can we do better than GCNs? What is Graph Attention Network (GAT) How does the GAT layer work? Description GAT (Graph Attention Network), is a novel neural network architecture that operate on graph-structured data, leveraging masked self-attentional layers to address the shortcomings of prior methods based on graph convolutions or their approximations. By stacking layers in which nodes are able to attend over their neighborhoods’ features, the method enables (implicitly) specifying different weights to different nodes in a neighborhood, without requiring any kind of costly matrix operation (such as inversion) or depending on knowing the graph structure upfront. In this way, GAT addresses several key challenges of spectral-based graph neural networks simultaneously, and make the model readily applicable to inductive as well as transductive problems.

Artificial Intelligence encircles a wide range of technologies and techniques that enable computer systems to solve problems like Data Compression which is used in computer vision, computer networks, computer architecture, and many other fields. Autoencoders are unsupervised neural networks that use machine learning to do this compression for us. This Autoencoders Tutorial will provide you with a complete insight into autoencoders in the following sequence: What are Autoencoders? The need for Autoencoders Applications of Autoencoders Architecture of Autoencoders Properties & Hyperparameters Types of Autoencoders Data Compression using Autoencoders (Demo)

Motivation As a part of this blog series, this time we’ll be looking at a spectral convolution technique introduced in the paper by M. Defferrard, X. Bresson, and P. Vandergheynst, on “Convolutional Neural Networks on Graphs with Fast Localized Spectral Filtering”. As mentioned in our previous blog on A Review : Graph Convolutional Networks (GCN), the spatial convolution and pooling operations are well-defined only for the Euclidean domain. Hence, we cannot apply the convolution directly on the irregular structured data such as graphs. The technique proposed in this paper provide us with a way to perform convolution on graph like data, for which they used convolution theorem. According to which, Convolution in spatial domain is equivalent to multiplication in Fourier domain. Hence, instead of performing convolution explicitly in the spatial domain, we will transform the graph data and the filter into Fourier domain. Do element-wise multiplication and the result is converted back to spatial domain by performing inverse Fourier transform. Following figure illustrates the proposed technique: But How to Take This Fourier Transform? As mentioned we have to take a fourier transform of graph signal. In spectral graph theory, the important operator used for Fourier analysis of graph is the Laplacian operator. For the graph G=(V,E), with set of vertices V of size n and set of edges E. The Laplacian is given by