Merge branch 'master' into IT18500790

README.md

@@ -10,3 +10,37 @@ Some travelers do not know much about trains and attractive destinations to choo
 Passengers cannot get information about train stopping station, facilities, and the time duration of the trip. Railway passengers cannot get the needful and exact information about their visiting places.
 When passengers booking the ticket they cannot be booked which seat they want and there is no process to suggest the most preferred seating place. It may cause personal conflicts between closely seated passengers due to differences of personal interest.
 Difficult to find the visitor's attracted places that are located near the trip route. Therefore unpopular attractions are missed by many travelers. It is affected by traveling passengers and the tourism industry.
+
+**Individual research question**
+***IT18500790***
+Some travelers do not know much about trains and attractive destinations to choose from. At present, there is no application to guide tourists to the tourist destinations of their choice. Therefore passenger needs to spend more time for find the visiting places. It may cause them to waste their time which can spend on their enjoyment.
+
+***IT18085822***
+Passengers cannot get information about train stopping station, facilities, and the time duration of the trip. Railway passengers cannot get the needful and exact information about their visiting places.
+
+***IT18001280***
+Providing a facility to view available seats and suggest the most suitable seating place for a particular passenger. Providing the selection facility to choosing the seating place according to their choice.
+
+***IT18148282***
+Suggest the best visiting places according to the passenger's personal trip plan. Providing the most suitable visiting places suggestions by using passenger's relevant information.
+
+
+**Individual Objectives**
+***IT18500790***
+Providing the most suitable train plan to the passenger according to their needs by using a machine learning algorithm.
+
+***IT18085822***
+Machine learning-based chat-bot app to interact with the user 24 X 7, providing relevant information like train facilities, place information which suggest by trip schedule, etc. to the users according to the user queries.
+
+***IT18001280***
+Sequentially predict the most suitable seat for the passenger by using a machine learning algorithm.
+
+***IT18148282***
+Suggest the best places to visit for the passenger using a machine learning algorithm by gathering relevant data from the railway passengers.
+
+
+**Solution**
+Passengers can select their train schedule for traveling. But sometimes they miss out on places of their choice. This situation can reduce if predicting the trip schedule they want.
+Presently passenger wants to find some information about the particular train and system solves that issue by introducing a new machine learning-based chat-bot app for the users. Users can get information about a specific location by using the chat-bot application.
+Providing a facility to view available seats and suggest the most suitable seating place for a particular passenger. Providing the selection facility to choosing the seating place according to their choice.
+Suggest the best visiting places according to the passenger's personal trip plan. Providing the most suitable visiting places suggestions by using passenger's relevant information.

chat.py

+import random
+import json
+
+import torch
+
+from model import NeuralNet
+from nltk_utils import bag_of_words, tokenize
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+with open('intents.json', 'r') as json_data:
+    intents = json.load(json_data)
+    
+FILE = "data.pth"
+data = torch.load(FILE)
+
+input_size = data["input_size"]
+hidden_size = data["hidden_size"]
+output_size = data["output_size"]
+all_words = data['all_words']
+tags = data['tags']
+model_state = data["model_state"]
+
+model = NeuralNet(input_size, hidden_size, output_size).to(device)
+model.load_state_dict(model_state)
+model.eval()
+
+bot_name = "Sam"
+print("Let's chat! (type 'quit' to exit)")
+while True:
+    # sentence = "do you use credit cards?"
+    sentence = input("You: ")
+    if sentence == "quit":
+        break
+
+    sentence = tokenize(sentence)
+    X = bag_of_words(sentence, all_words)
+    X = X.reshape(1, X.shape[0])
+    X = torch.from_numpy(X).to(device)
+
+    output = model(X)
+    _, predicted = torch.max(output, dim=1)
+
+    tag = tags[predicted.item()]
+
+    probs = torch.softmax(output, dim=1)
+    prob = probs[0][predicted.item()]
+    if prob.item() > 0.75:
+        for intent in intents['intents']:
+            if tag == intent["tag"]:
+                print(f"{bot_name}: {random.choice(intent['responses'])}")
+    else:
+        print(f"{bot_name}: I do not understand...")

intents.json

+{
+  "intents": [
+    {
+      "tag": "greeting",
+      "patterns": [
+        "Hi",
+        "Hey",
+        "How are you",
+        "Is anyone there?",
+        "Hello",
+        "Good day"
+      ],
+      "responses": [
+        "Hey :-)",
+        "Hello, thanks for visiting",
+        "Hi there, what can I do for you?",
+        "Hi there, how can I help?"
+      ]
+    },
+    {
+      "tag": "goodbye",
+      "patterns": ["Bye", "See you later", "Goodbye"],
+      "responses": [
+        "See you later, thanks for visiting",
+        "Have a nice day",
+        "Bye! Come back again soon."
+      ]
+    },
+    {
+      "tag": "thanks",
+      "patterns": ["Thanks", "Thank you", "That's helpful", "Thank's a lot!"],
+      "responses": ["Happy to help!", "Any time!", "My pleasure"]
+    },
+    
+    {
+      "tag": "anuradhapura-places",
+      "patterns": ["what are the places i can visit in anuradhapura?", "what are the places I can see in Anuradhapura?", "what are the locations I can see in Anuradhapura", "Why am i going to anuradhapuraya?","What are the tourist places in anuradhapura?"],
+      "responses": ["You can see Sigiriya, Ruwanweliseya, Thuparamaya, Isurumuniya and many other historical places in Anuradhapura"]
+    },
+     {
+      "tag": "create-sigiriya",
+      "patterns": ["who made sigiriya?", "who created sigiriya?", "who built sigiriya?","who built lion rock?"],
+      "responses": ["Sigiriya was built by King Kashyapa"]
+    },
+     {
+      "tag": "see-sigiriya",
+      "patterns": ["what can i see in sigiriya?", "why am i go to sigiriya?", "what are the beautiful places in sigiriya?","why am i go to lion rock?"],
+      "responses": ["You can see ancient ponds and wall art in the Sigiriya"]
+    },
+      {
+      "tag": "important-sigiriya",
+      "patterns": ["what is the important of the sigiriya?", "tell me about sigiriya?", "why people like sigiriya?","why is the important of the sigiriya for us?", "tell me about lion rock?","what is sigiriya?","what is the special of the sigiriya?"],
+      "responses": ["Sigiriya is one of the most valuable historical monuments of Sri Lanka. Referred by locals as the Eighth Wonder of the World this ancient palace and fortress complex has significant archaeological importance and attracts thousands of tourists every year. It is probably the most visited tourist destination of Sri Lanka."]
+    },
+      {
+      "tag": "when-sigiriya",
+      "patterns": ["when create sigiriya?", "when built sigiriya?", "which year made sigiriya"],
+      "responses": ["Since the 3th century BC Sigiriya was used as a monastery and after eight centuries it was turned into a royal palace"]
+    },
+      {
+      "tag": "old-sigiriya",
+      "patterns": ["how old sigiriya?", "how many years sigiriya?"],
+      "responses": ["Archeological excavations have proven that Sigiriya and its surrounding territories were inhabited for more than 4000 years."]
+    },
+     {
+      "tag": "crowd-sigiriya",
+      "patterns": ["how many peoples comes to the sigiriya in the one day?", "how many crowd visit to the sigiriya in a day?"],
+      "responses": ["Around 2000 people come to visit Sigiriya daily."]
+    },
+     {
+      "tag": "ticket-sigiriya",
+      "patterns": ["what is the ticket price of sigiriya", "entrance fee of sigiriya?"],
+      "responses": ["You should by a ticket which price of US$30 or 4620 LKR for tourists, or 50 LKR for Sri Lankan citizens."]
+    },
+      {
+      "tag": "heritage-sigiriya",
+      "patterns": ["is sigiriya world heritage?", "when sigiriya become the heritage?"],
+      "responses": ["Sigiriya  is a UNESCO listed World Heritage Site since 1982."]
+    },
+     {
+      "tag": "station-sigiriya",
+      "patterns": ["what is the nearest railway station to the sigiriya", "how long so far to closest railway station from sigiriya?","where is sigiriya"],
+      "responses": ["Habarna is the closet railway station to Sigiriya. It's 15km away from Sigiriya."]
+    },
+     {
+      "tag": "heigh-sigiriya",
+      "patterns": ["what is the height of sigiriya", "what is the peak of sigiriya?","elevation of sigiriya?","elevation of sigiriya"],
+      "responses": ["1,144 feet (349 metres) above sea level and is some 600 feet (180 metres) above the surrounding plain."]
+    },
+      {
+      "tag": "why-sigiriya",
+      "patterns": ["why create sigiriya", "what is reason for make sigiriya?","what is the main purpose of sigiriya","why built sigiriya"],
+      "responses": ["1In India he raised an army with the intention of returning and retaking the throne of Sri Lanka, which he considered to be rightfully his. Expecting the inevitable return of Moggallana, Kashyapa is said to have built his palace on the summit of Sigiriya as a fortress as well as a pleasure palace."]
+    }
+
+
+
+
+
+  
+  ]
+}

model.py

+import torch
+import torch.nn as nn
+
+class NeuralNet(nn.Module):
+    def __init__(self, input_size, hidden_size, num_classes):
+        super(NeuralNet, self).__init__()
+        self.l1 = nn.Linear(input_size, hidden_size) 
+        self.l2 = nn.Linear(hidden_size, hidden_size) 
+        self.l3 = nn.Linear(hidden_size, num_classes)
+        self.relu = nn.ReLU()
+    def forward(self, x):
+        out = self.l1(x)
+        out = self.relu(out)
+        out = self.l2(out)
+        out = self.relu(out)
+        out = self.l3(out)
+        # no activation and no softmax at the end
+        return out

nltk_utils.py

+import numpy as np
+import nltk
+#nltk.download('punkt')
+from nltk.stem.porter import PorterStemmer
+stemmer = PorterStemmer()
+
+def tokenize(sentence):
+    """
+    split sentence into array of words/tokens
+    a token can be a word or punctuation character, or number
+    """
+    return nltk.word_tokenize(sentence)
+
+
+def stem(word):
+    """
+    stemming = find the root form of the word
+    examples:
+    words = ["organize", "organizes", "organizing"]
+    words = [stem(w) for w in words]
+    -> ["organ", "organ", "organ"]
+    """
+    return stemmer.stem(word.lower())
+
+
+def bag_of_words(tokenized_sentence, words):
+    """
+    return bag of words array:
+    1 for each known word that exists in the sentence, 0 otherwise
+    example:
+    sentence = ["hello", "how", "are", "you"]
+    words = ["hi", "hello", "I", "you", "bye", "thank", "cool"]
+    bog   = [  0 ,    1 ,    0 ,   1 ,    0 ,    0 ,      0]
+    """
+    # stem each word
+    sentence_words = [stem(word) for word in tokenized_sentence]
+    # initialize bag with 0 for each word
+    bag = np.zeros(len(words), dtype=np.float32)
+    for idx, w in enumerate(words):
+        if w in sentence_words: 
+            bag[idx] = 1
+
+    return bag

sub_create_seat.php

+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta http-equiv="X-UA-Compatible" content="IE=edge">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Document</title>
+</head>
+<body>
+    
+</body>
+</html>
\ No newline at end of file

train.py

+import json
+import numpy as np
+
+import torch
+import torch.nn as nn
+from torch.utils.data import Dataset, DataLoader
+from nltk_utils import bag_of_words, tokenize, stem
+from model import NeuralNet
+
+with open('intents.json', 'r') as f:
+    intents = json.load(f)
+    
+all_words = []
+tags = []
+xy = []
+
+for intent in intents['intents']:
+    tag = intent['tag']
+    # add to tag list
+    tags.append(tag)
+    for pattern in intent['patterns']:
+        # tokenize each word in the sentence
+        w = tokenize(pattern)
+        # add to our words list
+        all_words.extend(w)
+        # add to xy pair
+        xy.append((w, tag))
+        
+ignore_words = ['?', '.', '!']
+all_words = [stem(w) for w in all_words if w not in ignore_words]
+all_words = sorted(set(all_words))
+tags = sorted(set(tags))
+print(tags)
+
+X_train = []
+y_train = []
+
+for (pattern_sentence, tag) in xy:
+    # X: bag of words for each pattern_sentence
+    bag = bag_of_words(pattern_sentence, all_words)
+    X_train.append(bag)
+    # y: PyTorch CrossEntropyLoss needs only class labels, not one-hot
+    label = tags.index(tag)
+    y_train.append(label)
+   
+X_train = np.array(X_train)
+y_train = np.array(y_train)
+
+class ChatDataset(Dataset):
+
+    def __init__(self):
+        self.n_samples = len(X_train)
+        self.x_data = X_train
+        self.y_data = y_train
+
+    # support indexing such that dataset[i] can be used to get i-th sample
+    def __getitem__(self, index):
+        return self.x_data[index], self.y_data[index]
+
+    # we can call len(dataset) to return the size
+    def __len__(self):
+        return self.n_samples
+        
+num_epochs = 1000
+learning_rate = 0.001
+batch_size = 8
+input_size = len(X_train[0])
+hidden_size = 8
+output_size = len(tags)
+print(input_size, output_size)
+
+dataset = ChatDataset()
+train_loader = DataLoader(dataset=dataset,
+                          batch_size=batch_size,
+                          shuffle=True,
+                          num_workers=0)
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+model = NeuralNet(input_size, hidden_size, output_size).to(device)
+
+criterion = nn.CrossEntropyLoss()
+optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)
+
+for epoch in range(num_epochs):
+    for (words, labels) in train_loader:
+        words = words.to(device)
+        labels = labels.to(dtype=torch.long).to(device)
+        
+        # Forward pass
+        outputs = model(words)
+        # if y would be one-hot, we must apply
+        # labels = torch.max(labels, 1)[1]
+        loss = criterion(outputs, labels)
+        
+        # Backward and optimize
+        optimizer.zero_grad()
+        loss.backward()
+        optimizer.step()
+    if (epoch+1) % 100 == 0:
+        print (f'Epoch [{epoch+1}/{num_epochs}], Loss: {loss.item():.4f}')
+        
+        
+print(f'final loss: {loss.item():.4f}')
+
+data = {
+"model_state": model.state_dict(),
+"input_size": input_size,
+"hidden_size": hidden_size,
+"output_size": output_size,
+"all_words": all_words,
+"tags": tags
+}
+
+FILE = "data.pth"
+torch.save(data, FILE)
+
+print(f'training complete. file saved to {FILE}')
+
+
+
+
+
+