GNN_Fuzzy.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Graph Neural Networks.\n",
    "\n",
    "    How do they work ?\n",
    "\n",
    "\n",
    "Graph Neural Networks (GNNs) are a class of neural networks designed to operate on graph-structured data. They are used to analyze and make predictions about graphs, such as social networks, protein networks, and transportation networks.\n",
    "\n",
    "A GNN typically consists of an encoder that maps the graph's nodes and edges to a low-dimensional representation, and a decoder that maps the low-dimensional representation back to the graph's nodes and edges. The encoder and decoder are connected by a series of layers, each of which performs a different operation on the graph's nodes and edges.\n",
    "\n",
    "The key feature of GNNs is that they can take into account the neighborhood structure of the graph, meaning the connections between nodes. This is done by using message passing mechanisms to propagate information between nodes. In each layer of the GNN, each node updates its representation by aggregating information from its neighboring nodes.\n",
    "\n",
    "There are different variants of GNNs, such as Graph Convolutional Networks (GCNs) and Graph Attention Networks (GATs), which use different techniques for message passing and aggregation. GCNs use convolutional operations to propagate information between nodes, while GATs use attention mechanisms to weight the importance of different neighbors.\n",
    "\n",
    "In summary, GNNs use message passing and aggregation mechanisms to incorporate the neighborhood structure of a graph into the neural network's computation, allowing it to make predictions about graph-structured data."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What is a Fuzzy Set ?\n",
    "\n",
    "A fuzzy set is a mathematical concept used to represent a set of elements where the membership of each element to the set is not necessarily binary (either true or false), but can be any value between 0 and 1. This allows for a more flexible and realistic representation of sets where there is uncertainty or imprecision in the membership of the elements.\n",
    "\n",
    "A fuzzy set can be defined by a membership function, which maps each element of the set to a value between 0 and 1. This value represents the degree of membership of the element to the set, with 0 indicating that the element does not belong to the set and 1 indicating that the element fully belongs to the set.\n",
    "\n",
    "For example, we can have a fuzzy set called \"cold\" with a membership function that assigns a value between 0 and 1 to each temperature, where 0 means the temperature is not cold at all and 1 means the temperature is very cold. The membership function assigns a value of 0.2 to 20 degrees Celsius, 0.7 to 10 degrees Celsius, and 0.9 to 0 degrees Celsius, indicating the degree of membership of these temperatures to the \"cold\" set.\n",
    "\n",
    "Fuzzy sets are widely used in fuzzy logic, control systems, image processing, and other areas to handle uncertainty and imprecision in real-world systems."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How does Fuzzy Logic Work ?\n",
    "\n",
    "Fuzzy logic is a mathematical logic that extends classical Boolean logic to handle uncertainty and imprecision. It is based on the concepts of fuzzy sets and fuzzy membership, which allow for a more flexible and realistic representation of sets and elements.\n",
    "\n",
    "In fuzzy logic, propositions can take on a truth value between 0 and 1, instead of just being true or false. This truth value represents the degree of truth of the proposition, with 0 indicating that the proposition is completely false and 1 indicating that it is completely true.\n",
    "\n",
    "Fuzzy logic operations include:\n",
    "\n",
    "    Fuzzification: It is the process of taking a crisp input (e.g. a temperature measurement) and translating it into a fuzzy set membership value.\n",
    "    Inference: It is the process of using a set of fuzzy rules to infer a conclusion based on the input. These rules are typically in the form of \"IF-THEN\" statements, where the antecedent is a fuzzy set representing the input and the consequent is a fuzzy set representing the output.\n",
    "    Defuzzification: It is the process of taking a fuzzy output and translating it back into a crisp output.\n",
    "\n",
    "Fuzzy logic is particularly useful in applications where there is a need to make decisions or control systems based on uncertain or imprecise data. Examples of such applications include automatic control systems, image processing, natural language processing, and decision support systems."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "How does Fuzzy modelling work ?\n",
    "\n",
    "Fuzzy modeling is a method of approximating a complex system by using mathematical concepts of fuzzy sets and fuzzy logic. The process of fuzzy modeling involves identifying the input variables and output variables of the system, and then using fuzzy logic to establish the relationships between them. The relationships are represented by fuzzy rules, which are logical statements that express the behavior of the system in terms of the input and output variables. The rules are then used to construct a fuzzy inference system, which can be used to make decisions or predictions based on the input data. The key characteristic of fuzzy modeling is that it can handle uncertainty and imprecision, which is often present in real-world systems."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import networkx as nx\n",
    "import numpy as np\n",
    "import skfuzzy as fuzz\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a graph representation of a simple computer network where A-> B-> C-> D-> E\n",
    "G = nx.Graph()\n",
    "G.add_nodes_from(['A', 'B', 'C', 'D', 'E'])\n",
    "G.add_edges_from([('A', 'B'), ('B', 'C'), ('C', 'D'), ('D', 'E')])\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the GNN architecture\n",
    "class GNN(nn.Module):\n",
    "    def __init__(self, input_dim, hidden_dim, output_dim):\n",
    "        super(GNN, self).__init__()\n",
    "        self.input_dim = input_dim\n",
    "        self.hidden_dim = hidden_dim\n",
    "        self.output_dim = output_dim\n",
    "        \n",
    "        self.conv1 = nn.Conv1d(input_dim, hidden_dim, kernel_size=1)\n",
    "        self.conv2 = nn.Conv1d(hidden_dim, output_dim, kernel_size=1)\n",
    "\n",
    "    def forward(self, x, adjacency_matrix):\n",
    "        x = self.conv1(x)\n",
    "        x = torch.relu(x)\n",
    "        x = torch.mm(adjacency_matrix, x)\n",
    "        x = self.conv2(x)\n",
    "        return x\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the input and target data\n",
    "input_data = np.random.rand(5, 1) # random input feature for each node\n",
    "target_data = np.random.rand(5, 1) # random target feature for each node\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert the input and target data to fuzzy sets\n",
    "input_data_fuzzy = [fuzz.trimf(input_data[i], [input_data[i] - 0.1, input_data[i], input_data[i] + 0.1]) for i in range(5)]\n",
    "target_data_fuzzy = [fuzz.trimf(target_data[i], [target_data[i] - 0.1, target_data[i], target_data[i] + 0.1]) for i in range(5)]\n",
    "\n",
    "input_data = torch.from_numpy(input_data).float()\n",
    "target_data = torch.from_numpy(target_data).float()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convert the graph to an adjacency matrix\n",
    "adjacency_matrix = nx.to_numpy_matrix(G)\n",
    "adjacency_matrix = torch.from_numpy(adjacency_matrix).float()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Initialize the GNN\n",
    "gnn = GNN(1, 8, 1)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define the loss function and optimizer\n",
    "criterion = nn.MSELoss()\n",
    "optimizer = optim.Adam(gnn.parameters())\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Train\n",
    "for epoch in range(100):\n",
    "    output = gnn(input_data, adjacency_matrix)\n",
    "    loss = criterion(output, target_data)\n",
    "    optimizer.zero_grad()\n",
    "    loss.backward()\n",
    "    optimizer.step()\n",
    "\n",
    "print('Training complete')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python",
   "version": "3.11.0 (main, Oct 24 2022, 18:26:48) [MSC v.1933 64 bit (AMD64)]"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "c261aea317cc0286b3b3261fbba9abdec21eaa57589985bb7a274bf54d6cc0a7"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}