7:00 – 4:00 ASRC PhD/NASA

• More adversarial herding: Bots increase exposure to negative and inflammatory content in online social systems
  • Social media can deeply influence reality perception, affecting millions of people’s voting behavior. Hence, maneuvering opinion dynamics by disseminating forged content over online ecosystems is an effective pathway for social hacking. We propose a framework for discovering such a potentially dangerous behavior promoted by automatic users, also called “bots,” in online social networks. We provide evidence that social bots target mainly human influencers but generate semantic content depending on the polarized stance of their targets. During the 2017 Catalan referendum, used as a case study, social bots generated and promoted violent content aimed at Independentists, ultimately exacerbating social conflict online. Our results open challenges for detecting and controlling the influence of such content on society.
  • Bot detection appendix
    • It occurs to me that if bots can be detected, then they can be mapped in aggregate on the belief map. This could show what types of beliefs are being artificially enhanced or otherwise influenced
• Migrating Characterizing Online Public Discussions through Patterns of Participant Interactions to Phlog. Done!
• Working my way through Grokking. Today’s progress:

  

  

  

  
  

  # based on https://github.com/iamtrask/Grokking-Deep-Learning/blob/master/Chapter6%20-%20Intro%20to%20Backpropagation%20-%20Building%20Your%20First%20DEEP%20Neural%20Network.ipynb
  import numpy as np
  import matplotlib.pyplot as plt
  import typing
  # methods --------------------------------------------
  
  
  # sets all negative numbers to zero
  def relu(x: np.array) -> np.array :
      return (x > 0) * x
  
  
  def relu2deriv(output: float) -> float:
      return output > 0 # returns 1 for input > 0
      # return 0 otherwise
  
  
  def nparray_to_list(vals: np.array) -> typing.List[float]:
      data = []
      for x in np.nditer(vals):
          data.append(float(x))
      return data
  
  
  def plot_mat(title: str, var_name: str, fig_num: int, mat: typing.List[float], transpose: bool = False):
      f = plt.figure(fig_num)
      np_mat = np.array(mat)
      if transpose:
          np_mat = np_mat.T
      plt.plot(np_mat)
      names = []
      for i in range(len(np_mat)):
          names.append("{}[{}]".format(var_name, i))
      plt.legend(names)
      plt.title(title)
  
  # variables ------------------------------------------
  np.random.seed(1)
  hidden_size= 4
  alpha = 0.2
  
  weights_input_to_1_array = 2 * np.random.random((3, hidden_size)) - 1
  weights_1_to_output_array = 2 * np.random.random((hidden_size, 1)) - 1
  # the samples. Columns are the things we're sampling
  streetlights_array = np.array( [[ 1, 0, 1 ],
                                  [ 0, 1, 1 ],
                                  [ 0, 0, 1 ],
                                  [ 1, 1, 1 ] ] )
  
  # The data set we want to map to. Each entry in the array matches the corresponding streetlights_array roe
  walk_vs_stop_array = np.array([1, 1, 0, 0]).T # and why are we using the transpose here?
  
  error_plot_mat = [] # for drawing plots
  weights_l1_to_output_plot_mat = [] # for drawing plots
  weights_input_to_l1_plot_mat = [] # for drawing plots
  
  iter = 0
  max_iter = 1000
  epsilon = 0.001
  layer_2_error = 2 * epsilon
  
  while layer_2_error > epsilon:
      layer_2_error = 0
      for row_index in range(len(streetlights_array)):
          # input holds one instance of the data set at a time
          input_layer_array = streetlights_array[row_index:row_index + 1]
          # layer one holds the results of the NONLINEAR transformation of the input layer's values (multiply by weights and relu)
          layer_1_array = relu(np.dot(input_layer_array, weights_input_to_1_array))
          # output layer takes the LINEAR transformation of the values in layer one and sums them (mult)
          output_layer = np.dot(layer_1_array, weights_1_to_output_array)
  
          # the error is the difference of the output layer and the goal squared
          goal = walk_vs_stop_array[row_index:row_index + 1]
          layer_2_error += np.sum((output_layer - goal) ** 2)
  
          # compute the amount to adjust the transformation weights for layer one to output
          layer_1_to_output_delta = (goal - output_layer)
          # compute the amount to adjust the transformation weights for input to layer one
          input_to_layer_1_delta= layer_1_to_output_delta.dot(weights_1_to_output_array.T) * relu2deriv(layer_1_array)
  
          #Still need to figure out why the transpose, but this is where we incrementally adjust the weights
          l1t_array = layer_1_array.T
          ilt_array = input_layer_array.T
          weights_1_to_output_array += alpha * l1t_array.dot(layer_1_to_output_delta)
          weights_input_to_1_array += alpha * ilt_array.dot(input_to_layer_1_delta)
  
          print("[{}] Error: {:.3f}, L0: {}, L1: {}, L2: {}".format(iter, layer_2_error, input_layer_array, layer_1_array, output_layer))
  
          #print("[{}] Error: {}, Weights: {}".format(iter, total_error, weight_array))
          error_plot_mat.append([layer_2_error])
  
          weights_input_to_l1_plot_mat.append(nparray_to_list(weights_input_to_1_array))
          weights_l1_to_output_plot_mat.append(nparray_to_list(weights_1_to_output_array))
  
          iter += 1
          # stop even if we don't converge
          if iter > max_iter:
              break
  
  print("\n--------------evaluation")
  for row_index in range(len(streetlights_array)):
      input_layer_array = streetlights_array[row_index:row_index + 1]
      layer_1_array = relu(np.dot(input_layer_array, weights_input_to_1_array))
      output_layer = np.dot(layer_1_array, weights_1_to_output_array)
  
      print("{} = {:.3f} vs. {}".format(input_layer_array, float(output_layer), walk_vs_stop_array[row_index]))
  
  # plots ----------------------------------------------
  
  f1 = plt.figure(1)
  plt.plot(error_plot_mat)
  plt.title("error")
  plt.legend(["layer_2_error"])
  
  plot_mat("input to layer 1 weights", "weight", 2, weights_input_to_l1_plot_mat)
  plot_mat("layer 1 to output weights", "weight", 3, weights_l1_to_output_plot_mat)
  
  
  
  plt.show()