Data Reflexions

Language Learning Data and Dubbing

Wed, 13 Dec 2017 00:00:00 -0500

Generative adversarial networks are ideal for producing deceptively convincing invented media when given only a set of training media. GANs do this by utilizing a pair of dueling neural networks, one $D$ , the detective network, being trained to detect counterfeit media generated by the other network $G$ , and the other network $G$ , the counterfeiter network, being trained to trick $D$ into thinking its generated media is from the training set. This process can is essentially a game, like tic-tac-toe, and can be solved similarly using minimax, optimizing for each player each turn. The example on the left shows generated living spaces.

We can apply this same GAN technique to the problem of matching mouth movement to an audio dub, resulting in a more realistic dubbing. This is done by first creating $G$ and $D$ from the genuine video and audio, where all that is generated is the expected face shape given the audio and background. Then feeding the foreign audio dub through the generator to get the new generated video file to match the foreign audio dub.

Preprocessing techniques such as audio spectrograms and 3D facial modeling can also be applied.

The diagram below shows the creation of $G$ and $D$ .

The following diagram shows utilizing $G$ , the original media, and the foreign audio dub to generate the new dubbed media.

These processes are further formalized in this paper.

A large amount of correctly subtitled media is required for this method to be effective. In this arena, Fluency Rodeo can greatly help.

Fluency Rodeo

Tue, 12 Dec 2017 00:00:00 -0500

One of the biggest problems in speech recognition and natural language processing is a lack of labeled data. As such, most recent techniques such as generative adversarial networks aim to be useful without much labeled data, but even then potential is limited by the lack of labeled data. One such lack is the matching of audio data to text data, i.e. subtitles.

Fluency Rodeo is a language learning tool that allows creating subtitles on audio and video media and turning these into flash cards that can be learned from using spaced repetition. The best way to learn a language is through immersion and media is an excellent way to get there. Allowing these data to be volunteered to improve speech recognition and natural language processing techniques could also be a great boon for researchers in these fields.

Spark Word2Vec on Reddit Comments

Tue, 05 Jan 2016 00:00:00 -0500

This post is a continuation of NLP on Reddit in which Spark is used with CoreNLP to gather sentiment on organizations from the Reddit comment corpus. Although traditional natural language processing is a natural way to derive meaning from sentences, when using an algorithm such as Word2Vec it is not necessary to provide tagging, parsing or deeper information about English because the algorithm only considers the word contexts.

As the name sugests, Word2Vec is designed to convert words to a vector of numbers representing that word’s semantic meaning. This is to say, if the vectors of two words have a high cosine similarity those two words would be expected to be semantically similar. Semantically similar here means that one word has a high probability of being a possible drop in replacement of the other word within the corpus text. For example, in most texts run through Word2Vec, the vector for “boy” would have highest cosine similarity to the vector for “girl” because one could be a replacement for the other.

Another similar word to both might be “teenager”, whereas “boy” would also have high similarity to “man”, but not to “woman” and “girl” would have high similarity to “woman” but not to “man”. From this it is possible to form a manner of semantic arithmetic. The phrase “man” is to “king” as “woman” is to “queen” can be written as below.

$V_{queen} - V_{woman} + V_{man} \approx V_{king}$

It is also possible to then cluster words by meaning by clustering their vectors using a method such as K-means. So given the words, “cat” “dog” “hamster” and “documents”, “documents” would be marked least similar. This method is applied to the movie reviews sentiment analysis Kaggle dataset in their Word2Vec NLP tutorial, which ultimately uses Gensim and K-means to cluster words and derive sentiment. This tutorial also explores Gensim further and provides some examples.

Spark offers its own implementation of Word2Vec which can be used with the ML pipeline, which will be a good match in applying to the Reddit comment corpus for January 2015. The source for this is available on github.

In order to produce these word vectors, Spark uses the Skip-Gram model. The variables $w_1, w_2, \dots, w_T$ represent the words in the corpus used and $k$ is the size of the training window, i.e. the context words to either side of the target word. The negative cost function is written below. The goal is to maximize the average log-probabilities of a word being used in its proper context of words.

$\frac{1}{T} \sum_{t = 1}^{T}\sum_{j=-k}^{j=k} \log p(w_{t+j} | w_t)$

The probability of predicting the word $w_i$ given the word $w_j$ is the softmax model as stated below. In this equation $u_w$ is the vector for word $w$ and $v_w$ is the vector for the context of word $w$ . $V$ is the total vocabulary size.

$p(w_i | w_j) = \frac{\exp(u_{w_i}^{\top}v_{w_j})}{\sum_{l=1}^{V} \exp(u_l^{\top}v_{w_j})}$

The diagram below from Tensorflow Word2Vec shows how the context words are used to deduce the target word. The context is used to produce softmax classifier results, the highest probable word of the vocabulary is then selected.

This can be sped up by using hierarchical softmax which avoids calculating the full probabilistic model, instead focussing on the most probable target words, and not including noise words.

There are a number of parameters that need to be specified before running Word2Vec. The vector size of each word chosen for the Reddit model was 300 and minimum number of word occurrences required before being included was set to 10. Below are the Word2Vec results shown with a react table built for this purpose. The table can filter via the inputs or order rows by clicking the sortable column headers.

Many interesting features can be derived from this including how competitors or related entities so often line up, “Nintendo” to “Sega”, “NFL” to “NBA”, “Disney” to “Pixar” etc.

Other options available for performing Word2Vec include Torch, Tensorflow and Deeplearning4j. Another common algorithm for word vector representation is GloVe. Overall, vector representation of words is a burgeoning tool for semantic analysis.

Resources:

1) T. Mikolov, et al. Efficient Estimation of Word Representations in Vector Space, 2013

2) T. Mikolov, et al. Distributed Representations of Words and Phrases and their Compositionality, 2013

3) Y. Goldberg, et al. word2vec Explained: Deriving Mikolov et al.’s Negative-Sampling Word-Embedding Method, 2014

Natural Language Processing with Spark on Reddit Comments

Mon, 04 Jan 2016 00:00:00 -0500

Ever since the beginnings of natural language processing starting with the Turing test, understanding human language has remained one of the most sought after achievements in artificial intelligence. Human languages are varied and complex and have evolved over thousands of years resulting in thousands of languages and dialects. Linguists can group and trace languages back to fundamental root languages, forming language trees such as the Indo-European and Uralic language families illustrated below.

Though just because a language is closer to the root, such as Latin to European Romance languages or Sanskrit to many Indian languages, doesn’t necessarily mean it is more fundamental such that it would be easier to process by a NLP system. Many attempts have been made to create simpler and more expressive languages, though none have all the properties of the mythic Universal Language. Some such invented languages include Esperanto, Lojban, Blissymbols and Basic English.

Basic English was designed to have only 850 words and a simplified grammer such that it could be easily learned and spoken globally. This appears at first to be a noble proposition, however it later inspired Newspeak which was introduced to the people of Oceania in the book 1984 as an attempt to control the population by limiting the ideas possible to express.

The Sapir–Whorf hypothesis proposes that the way people think is profoundly affected by the language they use. These language features include what is easy to express, what is difficult to express, and what must be expressed as a consequence of using the language. For example, English requires personal pronouns to have gender: he, she and it. In contrast, spoken Chinese makes no distinction as these are all pronounced “ta”. In the science fiction novel Babel-17 a language itself was weaponized as learning it acted as an intellectual contagion.

All of this complexity poses difficulties for natural language processing. In order to truly understand language it is first necessary to have the context of the world in which it exists. However, providing a computer with this context is quite difficult. Most modern machine translation systems take advantage of statistical models or more recently deep learning, however back when computers were less powerful and there was less data available, a linguistic approach was taken involving linguistic rules. A famous early example of this approach was used in the Georgetown experiment in 1954.

In this approach the text is first represented according to syntactic rules, the structure of the sentence, such as the sentence “the cat sat on the mat” shown below. This is then used to derive the semantics, the meaning of the sentence.

This approach seemed the best place to start in deriving sentiment from the 2015 Reddit comments corpus for named entities, such as organizations, if only to compare to more modern approaches. The source for this is available on github.

First, all comments for the month January 2015 was downloaded from the 2015 Reddit comments corpus, which was extracted on “Sat, 28 Feb 2015 11:50:07 GMT”. Next, to build the pipeline. The data was loaded into S3 where it could be easily processed and aggregated by Spark. Once this is complete Spark can be run using AWS EMR. Next, to parse the sentences. CoreNLP is a great choice for performing the initial NLP steps of tokenization, part of speech tagging, stemming, and named entity recognition.

These steps will first separate the sentences into tokens and tag them according to their type, “orange” is tagged adjective (JJ), “cat” is tagged noun (NN) etc. Stemming converts all words to word stems, “am”, “are”, and “is” becomes “be”, “walk”, “walked”, “walks”, and “walking” becomes “walk”. Named entity recognition (NER) marks if a noun is a special type, such as an organization.

CoreNLP has more advanced features, including sentence parsing and it’s own sentiment analysis. However, since only single entities, not whole comments are being considered, and this is a hefty task given every comment must be parsed, these were not included in the pipeline.

Now to apply our simple linguistic rules, these are direct adjectives of the form “adjective noun” and connected adjectives of the form “noun is adjective” to start. This can be illustrated with some examples generated using the CoreNLP demo.

Direct Adjectives

"The blue dog ate lasagna"

The/DT blue/JJ dog/NN ate/VBD lasagna/NN

(ROOT
  (S
    (NP (DT The) (JJ blue) (NN dog))
    (VP (VBD ate)
      (NP (NN lasagna)))))

Connected Adjectives

"The dog is blue"

The/DT dog/NN is/VBZ blue/JJ

(ROOT
  (S
    (NP (DT The) (NN dog))
    (VP (VBZ is)
      (ADJP (JJ blue)))))

Also word articles like “a” and “the” are ignored, the conjunction “and” is used for combination, and sequences of adjective modifiers and adjectives are applied to full nouns which may consist of multiple words. These results can be seen below in a table built for this purpose using React, Redux, Immutable, and Webpack. The table can be filtered by entering in the input and sorted by clicking the column title.

From here it is possible to filter to desired organizations, Subreddits and adjectives. For example filtering by “AMD” organization, the “pcmasterrace” Subreddit considers them “cheaper”, whereas “buildapc” Subreddit also says “just as good”. According to the “DotA2” Subreddit the “valve” organization is “lazy” but also “smart”.

Though of course these linguistic rules are simplistic and would certainly not be able to properly parse a sentence like the buffalo sentence. Though humans have difficulty with this sentence as well.

And even when the parsing is correct according to the syntax, that doesn’t necessarily lead to meaningful semantics, as is the case for the sentence “Colorless green ideas sleep furiously”.

However, for the simple case, simple parsing is sufficient. Though this can be greatly improved using neural network algorithms such as Word2Vec which is explored in the next post.

Links:
1) Spark analysis
2) Customizable table

The Nature of Data

Fri, 10 Jul 2015 00:00:00 -0400

New advances are continually being made in machine learning algorithms, improvements in recurrent and convolutional deep neural networks being some of the most notable recent examples. However, it’s often not the quality of the algorithm or even the quality of the data that leads to the best results, but the sheer amount of data that can be brought to bear against a problem.

"It's not who has the best algorithm that wins, it's who has the most data."
- Andrew Ng

As presented near the end of the excellent Machine Learning Coursera course, the graph below shows a small example of the data quantity vs. result accuracy phenomena in action as applied to the subject of Natural Language Disambiguation. Although there are diminishing returns, often in ML research getting a 75% prediction accuracy is easy whereas getting to 90% is near impossible, we can still see that the algorithms used don’t impact the results effectiveness nearly as much as the amount of data does.

Another way of phrasing this is that when the amount of data is small, most techniques used will inevitably overfit the provided examples unless pressure is explicitly applied, such as regularization, to prevent this. For example, A polynomial exists that can exactly match any n-dimensional set of values, however it almost certainly will not generalize to new values even if they follow the same general pattern as the original values because the model would be so hyper focussed on matching the training examples.

One could make an analogy here to the notion of perspective. Anyone brought up in a certain context, though well suited for its particular nuances, will be woefully unprepared, Prince and the Pauper style, for dealing with a new context.

Overfitting is a common problem in statistics where practitioners know if data is worked on long enough, it is possible to force it to say almost anything. One of the primary impediments to forming meaningful predictions based on historical data is the correlation vs. causation problem. Based only on a narrow set of information it is difficult to determine cause and effect.

There is a study targeted towards MBA finance students that shows an excellent correlation between butter production in Bangladesh and the S&P 500 Index between the 80s and 90s, but for any other years there is no correlation. This exemplifies the fact that there can exist strong correlations that don’t have any deeper meaning or explanation. This study also demonstrates that even reasonable theories that are propped up by supporting data may in reality be no more meaningful than butter to stock prices when viewed with greater context.

Correlation vs. causation problems appear all over the modern world. For example, in the case of finance it is of paramount importance to properly understand causation. Connections like: bad whether leads to low wheat production which implicates higher wheat prices which provokes unrest in the Middle East leading to low oil production and high oil prices. However, as complex as these connections can be, in the case of the stock market it’s also important to consider what the other traders, human and machine, think, and what they think other traders think and so on. This is one reason why oil prices continue to rise even when there is plenty of oil.

This meta-consideration is part of what makes the question of twitter funds interesting. Supposedly it is possible to track the mood of the general public using twitter and use it to predict stocks. Even if the study is flawed, it remains valid if traders believe in it and thus make it true. For instance when there was a lot of buzz around Anne Hathaway, the stock for Berkshire Hathaway shot up because trading machines saw a lot of positive talk about Hathaway and assumed the Berkshire Hathaway stock would rise. It made no difference whether in actuality it was Anne or Berkshire, the stock still went up in the short term.

This is part of what makes short term and high frequency trading unpredictable, it doesn’t matter if value is real or not. This isn’t all that surprising given that markets in general run almost entirely on faith. This is also why there are flash crashes involving trigger happy machines and fear filled traders. When asked about this, George Soros admitted the irony of hedge funds protecting investors from market volatility that hedge funds themselves create.

It’s hard to know whether the correlations being looked at are really predictive, or just random. Ultimately, the world is complicated and is often impossible to boil down to easily digestible ideas and sometimes it can’t be boiled down to anything at all. Though having more data and greater context certainly helps.

NMF and Crystallography

Sun, 09 Nov 2014 00:00:00 -0500

X-ray crystallography is the use of x-rays to determine the molecular structure of crystals. This underlying atomic structure can then be used to determine physical properties such as elasticity, tensile strength, conductivity, or superconductivity, making it an important tool for materials science. X-ray crystallography involves mounting a crystalline material on a platform, blasting it with x-rays at various angles and measuring the intensity of the reflected rays.

The graph of intensity against x-ray angle is referred to as the diffraction pattern, the peaks of which are used to determine atomic structure. Below is the diffraction pattern of silicon carbide.

However, considering there are an infinite number of possible alloy combinations, looking through all of them to find the ideal crystalline structure for a given use case is infeasible. This makes it an excellent place to employ a machine learning algorithm.

Non-negative Matrix Factorization is frequently used in recommendation systems, but is also uniquely well suited for deriving patterns from signal data. The basic principle is to represent all the signals as a matrix of values V, each row of numbers representing a single signal. The matrix factorization process then produces matrices W and H where W multiplied by H is an approximation of the original matrix V.

Another way of imagining this is as H, a series of base signals, and W the percentages of each of those base signals combined to produce B, the approximation of V.

In NMF, the goal is to minimize the error between the actual and derived signal matrix. Put another way, to minimize the Frobenius norm of the error matrix.

$f = { \frac{1}{2} \|V - WH\|^2 }$

One way of achieving this is using alternating least squares. In alternating least squares only one of the two matrices, W or H is updated to minimize the Frobenius norm each iteration. This is in contrast to gradient descent in which both are updated each iteration to approach a minima of the Frobenius norm. Via differential calculus, the following update equations can be derived.

$\frac{\partial f}{\partial H} = -W^TV + W^TWH \quad\quad\quad \frac{\partial f}{\partial W} = -VH^T + WHH^T$

Regularization can also be added for desired properties such as matrix sparcity. Since the most important aspects of the diffraction patterns are the peaks, most values in the base signals should be geared towards 0.

This process was applied to the Iron-Palladium-Galium alloy combinations and written up in a paper coauthored while working at NIST. Below is shown some derived signals from the W and H matrices, next to the experimental data.

Here is an example of 46% Iron, 26% Palladium and 28% Gallium. The percentage of each structure is shown as a slice of the pie. Each of the known structures are labeled and the de-convoluted signal is at the botom.

The results can be represented as a triangle of pie charts, the location of the pies showing the alloy composition and the slices of each pie representing percentages of the base signals.

One of the problems with using NMF for base diffraction pattern derivation is phase shifts. As the composition moves from mostly one type of atom to another, atoms will be swapped, though the crystalline structure may not change. This results in the peaks moving and NMF generating a new base signal when it should reuse one already generated as can be seen in BCC Fe (110). Despite phase shift deviations, NMF is useful in deriving base diffraction patterns and visualizing the results.

Resources:

1) C. J. Long, et al. Rapid identification of structural phases in combinatorial thin-film libraries using x-ray diffraction and non-negative matrix factorization, 2009

2) P. O. Hoyer, et al. Non-negative Matrix Factorization with Sparseness Constraints, 2004

3) P. Dai, et al. Synthesis and neutron powder diffraction study of the superconductor HgBa2Ca2Cu308 by T1 substitution, 1994

Adrift Generator

Sun, 17 Mar 2013 00:00:00 -0400

Constraint solving remains a niche art, which is in part why it’s so refreshing to find instances were it can be put to good use. Recently came across the Adrift puzzle game and thought it would be fun to create a puzzle solver and generator. Although it has been shown that the game is NP-complete that doesn’t necessarily mean we can’t write a speedy solver.

The goal in the Adrift game is to connect each of the color end point pairs by a string of blocks of the same color. From constraints extrapolated from this goal we can solve and even create new puzzles. A key insight that can be gleaned from this puzzle is that each color must be surrounded by exactly two of its color, unless it is on an end, in which case it is surrounded by exactly one of its color. Using this observation, we can write a simple solver for the first puzzle using SABR and extend this solver to even larger puzzles.

First we need to state that the allowed symbols are R (red), B (blue) and X (stone).

Sym { R B X }

Now we can set the board, this is simply stating all the blocks that exist in the puzzle which we can later constrain.

Board {

..... a0;
.... b0 b1;
... c0 c1 c2;
.... d0 d1;
..... e0;

x0 x1 x2 . y0 y1 y2;
x3 x4 x5 . y3 y4 y5;
x6 x7 x8 . y6 y7 y8;
}

Below is our first constraint. We tell the board the starting positions of R, B, and X and what we want to fill in via !X (not X) meaning it must be a color. We will do this with a requirement (Req) on the Board object.

Req Board {

      R;
     !X X;
   B !X X;
     !X !X;
      !X;

X X !X X !X X;
X X !X X !X X;
B !X !X X !X R;
}

Below we have the meat of our solver were we express block links. For a block to be a link it must be surrounded by exactly two of its color. The first represents the link block and the subsequents represent the blocks it is surrounded by.

This construct uses option (Opt) groups for each of the objects: link2, link3, link4. An option group is like a requirement, only that at least one, but not necessarily all of the requirements in the option group must be met. For example, in link3 we express that for whatever symbol occupies the first place, exactly two of the next three places must match this symbol.

Opt link2 { v v v }

Opt link3 { v !v v v }
Opt link3 { v v !v v }
Opt link3 { v v v !v }

Opt link4 { v v v !v !v }
Opt link4 { v v !v v !v }
Opt link4 { v v !v !v v }
Opt link4 { v !v v v !v }
Opt link4 { v !v v !v v }
Opt link4 { v !v !v v v }

Now we simply describe all of the objects that match up to our Opt groups using DesObj. Note that while Req and Opt can only contain symbols and temporary variables representing symbols, DesObj can only contain Board cells.

DesObj link3 { b0 a0 c1 c0 }
DesObj link4 { c1 b0 b1 d1 d0 }
DesObj link4 { d0 c0 c1 e0 x1 }
DesObj link4 { d1 e0 c1 c2 y1 }
DesObj link4 { e0 d0 d1 y0 x2 }
DesObj link4 { x2 e0 y0 x5 x1 }
DesObj link4 { x5 x2 y3 x8 x4 }
DesObj link3 { x7 x4 x8 x6 }
DesObj link3 { x8 x5 y6 x7 }
DesObj link4 { y1 d1 y2 y4 y0 }
DesObj link4 { y4 y1 y5 y7 y3 }
DesObj link3 { y7 y4 y8 y6 }

Running our source code with “./sabr 1 source” we get the only valid solution. This is quite a simple example, but we can easily extend this reasoning to create a more expressive solver and solve more complex puzzles.

You can try out the generator posted here. It works by picking five random location pairs for the five colors, solving it to make sure it can be solved, then trying to solve it again another way to make sure there is only one valid solution. It is fairly fast, generating a new 5x5 with five color puzzle every couple of minutes on a laptop. Here’s a little visualization that shows some of the puzzles it created. To complete the puzzle, click and drag the colored blocks.

They are not curated, so the difficulty curve is all over the map. Writing a program to automatically determine puzzle difficulty would be quite a challenge and likely delve into psychology, so it would probably be faster just to take a sample of solving times and use ascending order. As with many computing problems, it’s surprising how far can be reached just by counting.

Now.js

Sat, 29 Oct 2011 00:00:00 -0400

Have given Now.js a shot with an Invertris Javascript implementation and it turned out fairly well so wanted to provide a post mortem on the Invertris project and consider the Now.js framework and the Node.js ecosystem in general. Now.js certainly made writing socket style Javascript way easier after some time spent developing in it, though feels like there is a lot of magic happening under the hood. This is great for efficiency because naturally folks don’t want to have to worry about functionality that can be built by the framework itself, but it can lead to problems in latency and security.

It can sometimes be unclear when a variable set in the client would get to the server and although Now.js has disabled the ability to run client code on the server, it still seems possible a Now.js program could deliberately or inadvertently allow remote code execution via a variable transfer with a function prototype. This seems like a cool idea that could have disastrous security implications.

Then there is the problem with scaling, although this is more an issue with Node.js. The beauty of Node.js is that the system itself is quite simple, which contributes to why so many like it. It is single threaded with epoll/select style network io, exclusively uses network blocking, and runs entirely on event based callbacks. Unfortunately these can all lead to scalability issues including, but not limited to, load balancing and callback spaghetti.

Fortunately, there are a number of techniques and libraries available to help mitigate these issues. A common technique used is to have Nginx Upstream round robin to multiple identical nodes running on different ports. This can make use of all the CPUs on the machine and mitigate the risk of one client hogging all the IO like one grumpy guy trying to return a piece of fruit at the only cash register. Unfortunately, Nginx struggles with the raw TCP of Socket.io, on which Now.js is based, so decided to try to use another TCP load balancer going with the Unix one, Balance, as per the Unix Philosophy: Those who don’t understand UNIX are condemned to reinvent it, poorly.

Unfortunately, it had occasional handshake errors so in the end returned to a single node. In the future will likely switch to HAProxy or Nginx’s TCP plugin to provide fair load balancing via speedy worker threads.

Links:
1) The Game
2) The Source

SABR FAQ

Thu, 28 Jul 2011 00:00:00 -0400

This is a FAQ related to the programming language SABR, which can be found at sabrlang.org

1) It seems far removed from the problem, using a language to write out a problem to be solved by a satisfiability solver rather than solved by the compiler itself. Why do it that way?

The satisfiability problem is an ongoing field of research and there are continual advancements in distributed and machine learning based Conjunctive Normal Form (CNF) solvers, and there will likely be greater discoveries in the future. Many are already using satisfiability solvers to solve problems in spatial and temporal logic. However, although the problem of restating some problem as a CNF will undergo improvements, these improvements may be less significant than the progress made in CNF solvers. As the solvers improve, it will be possible to just hook in a new CNF solver, and it will suddenly solve the problem faster. If, for example, a neural network algorithm been used to solve the SABR language problem, this type of effortless advancement would not be possible.

2) Where does SABR fit in relation to other language?

SABR is a domain specific language that fits in the discrete spatial and temporal representation niche of the constraint programming niche, which is a pretty small piece of the overall programming pie, and can’t even claim to have a monopoly on that. However, SABR does have the potential to cause people to think differently about the problems they face and how they can be solved.

3) Is the language expected to grow much in the future?

The language is stripped down by design because it is expected that the problems fed to it will be complicated enough that bells and whistles would hurt performance too much. One of the design goals was that the language should have at or under an n-squared relationship between the size of the program and the size of the CNF so that users will get a sense of when their programs may be becoming unmanageable for the CNF solver. Although frequently more constraint can speed up CNF solving, CNF size is still a fair heuristic to use for time to solve. As an added bonus, since SABR has this property it can be used to show that a problem class is NP easy.

The addition of a SABR Python library could in the future have features like integer programming, tiling for bin packing, model checking, Computational Tree Logic (CTL) and Linear Temporal Logic (LTL). Computer languages, like computer software, often suffer from feature creep (i.e. Duke Neukem Forever syndrome). It has been said that all software inevitably evolves up to and beyond the point it includes an email server and it is arguably gratuitous that Prolog can be used to write a webserver. So instead of adding features using the language syntax, greater utility may be gained from adding features to a library which uses SABR.

4) Any other future use cases?

SABR could be used for program verification and model checking, potentially to analyze assembly or byte code. Could also be used with machine learning, distributed computing, and GPU based CNF solvers. Constraint solving is a multifaceted area, so there are lots of opportunities to explore.

Genetic Quine

Tue, 26 Jul 2011 00:00:00 -0400

Have just come across an interesting fact from a NOVA documentary on evolution. Bacteria are among the few creatures that use a rotary motor, their bacterial flagellum, for propulsion. The comments about it in this documentary also point out one of the fundamental flaws in genetic algorithms. From the perspective of the genetic algorithm there is a point A which is bad and point B which is substantially better, however in order for the genetic algorithm to venture from point A to point B most of the steps along the way have to show improvement. It may happen that there was an in between stage that was useful, as evidence shows happened in the bacteria’s case, but that relies a lot on luck.

However, genetic algorithms still have the potential to create unique solutions to problems. For instance, a genetic algorithm could be set up that would, with a little luck, eventually write a quine in C. To set up the environment, start by cutting the size to 200 characters (27 letters + 10 numbers + 20 misc = 57 possible chars) which is 57^200 possible programs. Put another way, many times more than the number of atoms in the universe (a mere 10^82), though ideally quickly narrows this number. Breeding is done by sporadic character insertion of two programs.

Next, to set up the reward structure. If the breeding produces a program that compiles, points for that offspring, increasing its longevity. If it produces output, more points. And if it starts to produce output identical to the front of its output, many more points. Finally, if it produces the exact same output as itself, it wins and the algorithm completes.

It does of course matter greatly how the environment is set up, in particular the breeding and rewards system. Using a language which offers fewer characters and is more likely to produce compilable output also increases the chance of success.

DNA is particularly elegant because so much produces viable candidates (creatures), which is ideal in genetic algorithms. The genetic algorithms batches just do the best they can with the parameters they are given. Living creatures are the same.