Flask app

Algorithm.py

@@ -3,18 +3,18 @@
 import Node as nn
 import math, random
 
-# Loop through database
-# If a node is negative, lower the chances of its neighbors being p_zero by their age likelihood
-# Sample most likely p_zero
-# Repeat
+class Algorithm():
+    def __init__(self, size, negativeEffectBias, positiveBias, positiveEffectBias, similarityWeight):
+      self.nodeLikelihoods = [1] * size
+      # self.percentSamplesAlloted = 0.2
+      # self.percentTracesAlloted = 0.05
 
-# After (.6 * SIZE) times:
-# Run simulation on most likely and find infection pattern
-# Calculate likelihood of being p_zero
+      self.negativeEffectBias = negativeEffectBias
 
-class Algorithm():
-    def __init__(self, size):
-        self.nodeLikelihoods = [5] * size
+      self.positiveBias = positiveBias
+      self.positiveEffectBias = positiveEffectBias
+
+      self.similarityWeight = similarityWeight
 
     def InitialScan(self, nodes):
         # All negative nodes can't be patient zero, and the chances
@@ -23,18 +23,18 @@ def InitialScan(self, nodes):
             if node.state == 0:
                 self.nodeLikelihoods[node.id] = 0
                 for neighbor in node.connections:
-                    self.nodeLikelihoods[neighbor.id] /= 2
+                    self.nodeLikelihoods[neighbor.id] -= self.negativeEffectBias
             elif node.state == 1:
-                self.nodeLikelihoods[node.id] += 0.1
+                self.nodeLikelihoods[node.id] += self.positiveBias
                 for neighbor in node.connections:
-                    self.nodeLikelihoods[neighbor.id] += 0.1
-    
+                    self.nodeLikelihoods[neighbor.id] += self.positiveEffectBias
+
     def ChooseOneToSample(self, player):
         # Find most likely after initial scan
         self.InitialScan(player.nodes)
 
         save = []
-        
+
         for node in player.sampled:
             save.append((player.nodes[node].id, self.nodeLikelihoods[node]))
             self.nodeLikelihoods[node] = -999
@@ -43,26 +43,26 @@ def ChooseOneToSample(self, player):
 
         for Id, likelihood in save:
             self.nodeLikelihoods[Id] = likelihood
-        
+
         # Find most likely nodes and sample them
         likelyNodes = []
         for node in player.nodes:
             if self.nodeLikelihoods[node.id] == mostLikely:
                 likelyNodes.append(node.id)
-        
+
         return random.choice(likelyNodes) 
-       
-    def FindDifference(list1, list2):
+
+    def FindDifference(self, list1, list2):
         # Calculate Jaccard similarity
         intersection = len(set(list1).intersection(set(list2)))
         union = len(set(list1).union(set(list2)))
         jaccard_similarity = intersection / union
-        
+
         return jaccard_similarity
 
     def TraceSpreadPattern(self, Player, target_node):
         new_player = copy.deepcopy(Player)
-        
+
         # Reset infections
         for node in new_player.nodes:
             node.state = 0
@@ -72,10 +72,10 @@ def TraceSpreadPattern(self, Player, target_node):
         infectionsForNewPlayer = [node.state for node in new_player.nodes]
         infectionsForCurrentPlayer = [node.state for node in Player.nodes]
 
-        difference = math.fabs(Algorithm.FindDifference(infectionsForNewPlayer, infectionsForCurrentPlayer))
+        difference = math.fabs(self.FindDifference(infectionsForNewPlayer, infectionsForCurrentPlayer))
+
+        self.nodeLikelihoods[Player.nodes[target_node].id] -= (difference * self.similarityWeight)
 
-        self.nodeLikelihoods[Player.nodes[target_node].id] -= difference
-
     def getSortedIds(self):
         indexed_arr = [(value, index) for index, value in enumerate(self.nodeLikelihoods)]
 
@@ -85,4 +85,4 @@ def getSortedIds(self):
         # Extract the sorted indices
         sorted_indices = [index for _, index in sorted_arr]
 
-        return sorted_indices
+        return sorted_indices

Graph.py

@@ -0,0 +1,85 @@
+import networkx as nx
+import matplotlib.pyplot as plt
+from pyvis.network import Network
+
+def CreateGraphHTML(player, path):
+  G = nx.Graph()
+
+  elements = []
+
+  for i, node in enumerate(player.nodes):
+
+    if node.visibleToPlayer:
+      if node.state == 1 and node.isPatientZero:
+        status = "Infected"
+        color = "purple"
+      elif node.state == 1:
+        status = "Infected"
+        color = "red"
+      else:
+        status = "Not Infected"
+        color = "green"
+    else:
+      status = "Unknown"
+      color = "gray"
+
+    elements.append((i, {"ID": str(node.id),\
+                         "Status": status,\
+                         "color": color,\
+                         "Age": str(node.age),\
+                         "Connections": str(node.connectNumbers),\
+                         "TimeInfected": str(node.timeInfected) if node.timeInfected else "N/A",\
+                         "chosen": node.selectedByAI
+                        }))
+
+  G.add_nodes_from(elements)
+
+  for node in player.nodes:
+    for connection in node.connectNumbers:
+      G.add_edge(node.id, connection)
+
+  nt = Network(notebook=True)
+  nt.from_nx(G)
+
+  nt.width = "70%"
+
+  nt.set_options("""
+      var options = {
+        "physics": {
+          "forceAtlas2Based": {
+            "springLength": 100
+          },
+          "minVelocity": 0.75,
+          "solver": "forceAtlas2Based"
+        }
+      }
+      """)
+
+  # Add node information to be displayed on hover
+  for node in nt.nodes:
+      node_str = """Node {ID} - Status: {Status}
+
+                    Age: {Age} y/o
+                    Connections: {Connections}
+                    Time Infected: {TimeInfected}
+
+                    Chosen By AI: {chosen}
+                    """
+      node["title"] = node_str.format(**node)
+
+      if node["chosen"] == "True":
+        node["size"] = 30
+
+  # nt.show("template.html")  # Save the visualization to an HTML file
+
+  html = nt.generate_html().split("\n")
+
+  if len(player.nodes) < 100:
+    node_line, edges_line = 90, 91
+  else:
+    node_line, edges_line = 168, 169
+
+  nodes = html[node_line]
+  edges = html[edges_line]
+
+  return nodes, edges

Node.py

@@ -12,13 +12,10 @@ def __init__(self, id, centerValues):
     self.visibleToPlayer = False
     self.isPatientZero = False
     self.timeInfected = None
+    self.selectedByAI = "False"
 
-    while True:
-      self.X = random.randint(2, 98) * 30
-      self.Y = random.randint(2, 98) * 30
-
-      if (self.X, self.Y) not in centerValues:
-        break
+    self.X = 0
+    self.Y = 0
 
     self.age = random.randint(1, 80)
 
@@ -55,12 +52,13 @@ def calculateLikelihood(self, enableAlwaysInfection=False):
   def infectNeighbors(self, time):
     # Infect all uninfected neighbors
     for neighbor in self.connections:
-      # Calculate infection likelihood
-      likelihood = neighbor.calculateLikelihood()
-
-      if random.randint(0, 1000)/10 <= likelihood:
-        neighbor.state = 1
-        neighbor.timeInfected = time
+      if neighbor.state == 0:
+        # Calculate infection likelihood
+        likelihood = neighbor.calculateLikelihood()
+
+        if random.randint(0, 1000)/10 <= likelihood:
+          neighbor.state = 1
+          neighbor.timeInfected = time
 
 def createNodeNetwork(numberOfNodes, nodes, min_connections, max_connections):
   # Initialize center values:
@@ -79,18 +77,6 @@ def createNodeNetwork(numberOfNodes, nodes, min_connections, max_connections):
   for node in nodes:
     node.makeConnections(nodes, min_connections, max_connections)
 
-  # print("------ Creating Network -----")
-
-  # For testing: Print network of nodes
-  # for i in range(len(nodes)):
-    #neighborPos = nodes[i].connectNumbers
-#please do not touch this code i had to go but i will get this sorted out pls pls thanks
-    # print(f"Node {i}: Connected with {nodes[i].connectNumbers}")
-
-    #window.DrawLines(i, neighborPos)
-
-  # print("--------- DONE -----------")
-
 def runInfectionSimulation(numDays, nodes, selected_p_zero=None):
   # Select patient zero
   p_zero = selected_p_zero if selected_p_zero else random.choice(nodes)
@@ -116,4 +102,4 @@ def runInfectionSimulation(numDays, nodes, selected_p_zero=None):
       if node.state == 1:
         node.infectNeighbors(day)
 
-  return p_zero.id
+  return p_zero.id

Player.py

@@ -2,12 +2,12 @@
 import Node as nn
 
 class Player():
-    def __init__(self):
+    def __init__(self, size, time, min, max, percent):
         self.nodes = [] # list of "Node" objects
-        self.size = 820
-        self.time = 4
-        self.min_connections, self.max_connections = 1, 2
-        self.num_visible_to_player = round(0.3 * self.size) # Replace .1 with percent nodes visible to player
+        self.size = size
+        self.time = time
+        self.min_connections, self.max_connections = min, max
+        self.num_visible_to_player = round(percent * self.size) # Replace .1 with percent nodes visible to player
 
         # new shit
         self.sampled = []
@@ -54,4 +54,3 @@ def lockin(self, prediction_id):
             self.is_winner = False
 
         self.is_done = True
-