Using Stochastic Processes to Help Humanize Artificial Intelligence

In developing examples for my book on HTML5 Canvas (HTML5 Canvas for Dummies) I experimented with using stochastic processes to improve the realism of an animated displays. Early versions of the displays appeared rigid and artificial. Adding stochastic (random) variations brought the displays closer to real life and made them much more fun to watch.

Stochastic processes are already important to AI. Stochastic Gradient Descent combined with Backpropagation is used to iteratively modify data values passed between neural network nodes in order to minimize the error between the output of the neural network and the correct/true result.

Recently, I've explored whether stochastic techniques can be used to help humanize AI. Humans are not robots. We don't mindlessly pursue objectives without variation from a given path. A more human-like AI would certainly make the man-machine interface more pleasant to deal with than a purely robotic one. There are certainly AI applications where we don't want these kind of random variations taking place ... in autonomous vehicles for example. 

You can experiment with one of my displays that employs stochastic processes ... click here to see it in action - once it's started, click control to see the variables you can modify using your keyboard.

View fullsize

Software Components Overview

Below is a list of links to and brief descriptions of common software components. It's useful to keep these in mind and reference them during software design as a shorthand for code that will be written to implement the design. Implementing a component could involve just a few or many lines of code.

A suggested way to use these components in solving/coding a computing problem is to include them using a Separation of Concerns design pattern folded into what I call Layered Logic Problem Solving that includes these steps:

1. Describe in words the problem to be solved. This might include references to software components listed below. You might also include solution acceptance criteria, possibly in the form of formal acceptance tests.
2. Draw a block diagram of the main problem solution pieces. For more complex problems, other types of diagrams can be used.
3. Annotate the block diagram with references to components such as those below.
4. Code the solution in your chosen programming language.

Communications

• Client-Server Architecture: components include:
  • Client
  • Server
  • REST
  • HTTP
  • JSON
  • Database
• HTTP Request: indicates the desired action to be performed on an identified resource - actions include: 
  • GET: retrieve data
  • HEAD: retrieve without response body
  • POST: create new subordinate data
  • OPTIONS: retrieve supported actions
  • PUT: create/replace data
  • DELETE: delete the resource
  • CONNECT: convert connection to TCP/IP tunnel, usually to facilitate HTTPS SSL
• Internet Protocol Suite:
  • Layers: Application/Transport/Internet/Link
  • Levels: Send/Receive, Controls/Routing, Values/Translations
• Firewall: monitor/control of incoming/outgoing traffic
• JSON: JavaScript Object Notation, Human Readable, Attribute-Value Pairs, Java JsonObject
• Load Balancer: distributes workload across computing resources
• Message: data sent across processes
• Network: allows computers to exchange data
• Protocol: Data Formats, Address Formats, Address Mapping, Routing, Error Detection, Acknowledgements, Sequence Control, Flow Control
• REST: Representational State Transfer, Stateless, Client-Server, JSON data
• Socket: endpoint of a connection across a computer network

Data

• Adapter:  binds data and views, moves data into a view
• Big O Notation: O(1), O(log (n)), O(n), O(n log(n)), O(n^2)
• Collection:  static operations on data objects … search, sort, transform...
• Java Data Structures: Array, List, ArrayList, Vector, Stack, Queue, LinkedList, Set, HashMap, TreeMap
• Comparator:  for special sort criteria
• DB: SQL, NoSQL, Couch, Hierarchical
• Dictionary: key/value pairs, hashtable, get( ), put( )/add( ), remove( )
• Document Object Model: convention for interacting with objects in HTML/XML documents
• File System: often use B-Tree data structures:
  • Disk: FAT(legacy), NTFS(Microsoft), HFS(Apple)  
  • Network: NFS  
• Graph Theory: elements include:
  • objects/pointers
  • adjacency matrix
  • adjacency list
  • graph travel algorithms
  • breadth-first search
  • depth-first search
• Irrational Number: a real number that cannot be expressed as a ratio of integers, i.e. as a fraction; therefore, irrational numbers, when written as decimal numbers, do not terminate, nor do they repeat
• Iterator  next, previous, …
• Join (SQL): combines records from two or more tables in a relational database
  • Inner: requires matching record of joined tables for new table
  • Outer: does not require matching record of joined tables for new table
  • Left: all records of left table even if no matching record in right table
  • Right: all records of the right table even if no matching record in the left table
• Logarithms: i.e: 64=2^6  ==  log2(64)=6
• Pattern Matching: Find patterns in a character sequence; can use Regular Expressions
• Poisson Distribution: a discrete probability distribution that expresses the probability of a given number of events occurring in a fixed interval of time and/or space if these events occur with a known average rate and independently of the time since the last event
• Primitives: Java example: 
  • char: 16-bit unicode
  • boolean: true, false
  • double: 64-bit floating point
  • float: 32-bit floating point
  • long: 64-bit signed integer
  • int: 32-bit signed integer
  • short: 16-bit signed integer
  • byte: 8-bit signed
• Rational Number: any number that can be expressed as the quotient or fraction p/q of two integers, a numerator p and a non-zero denominator q
• Regular Expressions: special characters include:
  • . any char
  • ? zero or one occurrences of the preceding element
  • * zero or more occurrences of the preceding element
  • + one or more occurences of the preceding element
  • ^ starting pos
  • $ ending pos
  • [ ] any char in brackets
  • | or
  • \ esc
• Relational Database: Data organization based on one or more tables of keys and values
• SCRUD:  Search, Create, Read, Update/add, Delete
• Search:  algorithm for finding an item within a data group
  • Binary: search of sorted list in O(log(n)) time
  • Linear: search of an unsorted list in O(n/2) time
• Sort: use the sort built into a programming language whenever possible but if a customized sort is needed, here are some examples:
  • Bubble: O(n^2) passes over data to move each element up to correct position
  • Insertion: O(n^2) one by one element insertion into (usually already sorted) list, not efficient
  • Quick: O(n log(n)) Java default, pivot point, greater above, lesser below, repeat until done
  • Merge: O(n log(n)) series of lists progressively joined
  • Java Collections Sort: Merge Sort, efficient, much less than O(n log(n)), uses intermediate array
• Tensor: multi-dimensional array of data that provides values used to apply changes to target objects
• Trees: root with subtrees, linked nodes
  • Binary Tree: each node has <=2 children
  • Binary Search Tree: sorted, fast lookup/add/remove, used in file systems
  • k-d Tree: k dimensional, space-partitioning, nearest neighbor search
  • Red-Black Tree: self-balancing, binary search tree, extra bit per node
• Two’s Complement: high bit determines sign
• Type System:
  • static/dynamic: compilation
  • strong/weak: changing   

Algorithms & Processes

• Algorithm Design: Big O, Design Patterns, Data Structures, Sort, Flow Components
• A* Search: plotting an efficiently traversable path between nodes
• Android App Major Elements: Intent Messaging, Services/Activities/UI, Async Operations, Data/Devices/Sensors, Reference Elements
• Bayes' Theorem: describes the probability of an event, based on conditions that might be related to the event
• Boundary Case: values beyond minimum or maximum
• Buffer: physical memory, temporary
• Callback: code passed for automatic future execution
• Coefficient: a multiplicative factor in some term of a polynomial, a series or any expression; it is usually a number, but in any case does not involve any variable of the expression
• Combinatorics: study of finite or countable discrete structures
• Conditional:  if, else, else if
• Convolutional Neural Network: type of feed-forward artificial neural network in which the connectivity pattern between its neurons is inspired by the organization of the animal visual cortex
• Corner Case: outside of normal operating parameters
• Function Model: activities, actions, processes (not using object orientation)
• Dijkstra Algorithm: shortest path between two nodes in a graph
• Dynamic Programming: divide > solve > save > reuse
• Edge Case: very small, very large, too much memory
• Error Handling: exceptions, logging, stack trace, checked exceptions, restarts
• Context/Switching: save/restore state, allow multitasking, threads, interrupts
• Divide and Conquer: multi-branch recursion, used for sorting
• Function:  method, subroutine, block
• Greedy Algorithm: Algorithm that makes the locally optimal choice at each stage with the hope of finding a global optimum
• Iteration:  for, while, until ...
• Least Squares: approach in regression analysis in which the overall solution minimizes the sum of the squares of the errors made in the results of every single equation
• Matrix Mathematics: the application of mathematical operations to matrices
  • Python Matrix Class: many methods for performing operations on matrices
• Monte Carlo Method: algorithm that rely on repeated random sampling to obtain numerical results
• Neural Network: highly interconnected layers of nodes and data flows that process machine learning algorithms
  • Logistic Regression: regression model where the dependent variable (DV) is categorical
  • Rectifier: used to linearize vectors
• Pipeline: first | second | third | nth
• Probability: independent events multiply probabilities, mutually exclusive events add probabilities
• Locks: deadlock, livelock
• Probability Density: or density of a continuous random variable, is a function that describes the relative likelihood for this random variable to take on a given value
• Random Walk: formalization of a path that consists of a succession of random steps
• Recursion:  perform action, test for end case, call self
• Regression Analysis: statistical process for estimating the relationships among variables; helps one understand how the typical value of the dependent variable (or 'criterion variable') changes when any one of the independent variables is varied, while the other independent variables are held fixed
• Reflection: examine/change properties during execution
• Stocastic Process: or random process, is a collection of random variables representing the evolution of some system of random values over time
• Switch:  case/variable
• Synchronization:
  • Processes: handshakes, locks
  • Data: multiple copy coherence
• Thread: Android examples of thread handling:
  • AsyncTask
  • Loader

Objects

• Class: object template
• Container: collection of other objects
• Design Patterns: reusable solutions to common software problems  
• Object Oriented Design Patterns: reusable solutions to common object oriented software problems
• Generics: specify type or method to operate on objects
• Cloud Computing: internet based computing that provides shared processing resources
• Interface : all abstract methods
• Mutability: mutable, immutable, strong vs. weak
• Objects: variables, data structure or function referenced by an identifier
• OOD: uses inheritance, abstraction, polymorphism, encapsulation, other design patterns

Views

• Ajax: groups of technologies for client-side asynchronous web applications
• Android Fragments: UI segmenting, own lifecycle, FragmentManager
• HTML5 Canvas:  bitmap, javascript
• CSS:  describes the presentation of information
• HTML:  head, body, div, script
• Widget: simple, easy to use applicator
• XML: markup language that defines a set of rules for encoding documents

Type System

A type system is a collection of rules that assign a property called type to constructs such as variables, functions, expressions and modules. Here are the two main dimensions of typing and some programming language examples:

Static vs. Dynamic

• static:  type is set during compile
• dynamic: type is set during execution

Strong vs. Weak

• strong: type cannot change during execution
• weak: type can change during execution

Language Examples

• C: Weak Static
• C++: Weak Static
• Java: Strong Static
• JavaScript: Weak Dynamic
• Perl: Weak Dynamic
• Python: Strong Dynamic
• Ruby: Strong Dynamic