Datasets:

Fraser
/

dream-coder

Languages:

English

Tags:

program-synthesis

License:

Dataset card Viewer Files Files and versions Community

dream-coder / dreamcoder /likelihoodModel.py

Fraser-Greenlee

add dataset code

3bdb76c over 2 years ago

raw history blame contribute delete

No virus

15.1 kB

	from dreamcoder.task import Task, EvaluationTimeout
	import gc
	from dreamcoder.utilities import *
	from collections import Counter
	import math

	from dreamcoder.domains.regex.groundtruthRegexes import gt_dict

	gt_dict = {"Data column no. "+str(num): r_str for num, r_str in gt_dict.items()}

	class AllOrNothingLikelihoodModel:
	def __init__(self, timeout=None):
	self.timeout = timeout

	def score(self, program, task):
	logLikelihood = task.logLikelihood(program, self.timeout)
	return valid(logLikelihood), logLikelihood


	class EuclideanLikelihoodModel:
	"""Likelihood is based on Euclidean distance between features"""

	def __init__(self, featureExtractor, successCutoff=0.9):
	self.extract = featureExtractor
	self.successCutoff = successCutoff

	def score(self, program, task):
	taskFeat = self.extract.featuresOfTask(task)
	progFeat = self.extract.featuresOfProgram(program, task.request)
	assert len(taskFeat) == len(progFeat)
	distance = sum((x1 - x2)**2 for x1, x2 in zip(taskFeat, progFeat))
	logLikelihood = float(-distance) # FIXME: this is really naive
	return exp(logLikelihood) > self.successCutoff, logLikelihood

	def longest_common_substr(arr):
	#array of examples

	# Python 3 program to find the stem
	# of given list of words
	# function to find the stem (longest
	# common substring) from the string array
	# Determine size of the array
	n = len(arr)

	# Take first word from array
	# as reference
	s = arr[0]
	l = len(s)
	res = ""
	for i in range(l) :
	for j in range( i + 1, l + 1) :
	# generating all possible substrings
	# of our reference string arr[0] i.e s
	stem = s[i:j]
	k = 1
	for k in range(1, n):

	# Check if the generated stem is
	# common to to all words
	if stem not in arr[k]:
	break

	# If current substring is present in
	# all strings and its length is greater
	# than current result
	if (k + 1 == n and len(res) < len(stem)): res = stem
	return res

	def add_string_constants(tasks):
	for task in tasks:
	task.str_const = longest_common_substr([example[1] for example in task.examples])
	return tasks

	def get_gt_ll(name, examples):
	#gets groundtruth from dict
	import pregex as pre
	r_str = gt_dict[name]
	preg = pre.create(r_str)

	if type(examples[0]) == list:
	examples = [ "".join(example) for example in examples]

	s = sum( preg.match(example) for example in examples)
	if s == float("-inf"):
	print("bad for ", name)
	print('preg:', preg)
	print('preg sample:', [preg.sample() for i in range(3)])
	print("exs", examples)
	#assert False
	return s


	def add_cutoff_values(tasks, ll_cutoff):
	from dreamcoder.domains.regex.makeRegexTasks import makeNewTasks
	if ll_cutoff is None or ll_cutoff == "None":
	for task in tasks:
	task.ll_cutoff = None
	return tasks
	if ll_cutoff == "gt":
	from dreamcoder.domains.regex.makeRegexTasks import regexHeldOutExamples
	for task in tasks:
	task.ll_cutoff = None
	task.gt = get_gt_ll(task.name, [example[1] for example in task.examples])
	task.gt_test = get_gt_ll(task.name,
	[example[1] for example in regexHeldOutExamples(task) ])
	return tasks
	elif ll_cutoff == "plus":
	for task in tasks:
	task.ll_cutoff = regex_plus_bound([example[1] for example in task.examples])
	return tasks
	elif ll_cutoff == "bigram":
	eprint("WARNING: using entire corpus to make bigram model")
	#this means i do it twice, which is eh whatever
	model = make_corpus_bigram(show_tasks(makeNewTasks()))
	for task in tasks:
	task.ll_cutoff = bigram_corpus_score([example[1] for example in task.examples], model)
	return tasks
	elif ll_cutoff =="unigram":
	eprint("WARNING: using entire corpus to make unigram model")
	#this means i do it twice, which is eh whatever
	model = make_corpus_unigram(show_tasks(makeNewTasks()))
	for task in tasks:
	task.ll_cutoff = unigram_corpus_score([example[1] for example in task.examples], model)
	return tasks
	elif ll_cutoff =="mix":
	eprint("WARNING: using entire corpus to make bigram model")
	eprint("WARNING: using entire corpus to make unigram model")
	#this means i do it twice, which is eh whatever
	unigram = make_corpus_unigram(show_tasks(makeNewTasks()))
	bigram = make_corpus_bigram(show_tasks(makeNewTasks()))
	for task in tasks:
	uniscore = unigram_corpus_score([example[1] for example in task.examples], unigram)
	biscore = bigram_corpus_score([example[1] for example in task.examples], bigram)
	task.ll_cutoff = math.log(0.75math.exp(biscore) + 0.25math.exp(uniscore))
	return tasks
	else:
	eprint("not implemented")
	eprint("cutoff val:")
	eprint(ll_cutoff)
	assert False

	def show_tasks(dataset):
	task_list = []
	for task in dataset:
	task_list.append([example[1] for example in task.examples])
	return task_list

	def regex_plus_bound(X):
	from pregex import pregex
	c = Counter(X)
	regexes = [
	pregex.create(".+"),
	pregex.create("\d+"),
	pregex.create("\w+"),
	pregex.create("\s+"),
	pregex.create("\\u+"),
	pregex.create("\l+")]
	regex_scores = []
	for r in regexes:
	regex_scores.append(sum(c[x] * r.match(x) for x in c)/float(sum([len(x) for x in X])) )
	return max(regex_scores)


	def make_corpus_unigram(C):
	str_list = [example + '\n' for task in C for example in task]
	c = Counter(char for example in str_list for char in example )
	n = sum(c.values())

	logp = {x:math.log(c[x]/n) for x in c}
	return logp

	def unigram_corpus_score(X, logp):
	task_ll = 0
	for x in X:
	x = x + '\n'
	task_ll += sum( logp.get(c, float('-inf')) for c in x)/len(x)

	ll = task_ll/len(X)
	return ll

	def unigram_task_score(X):
	"""
	Given a list of strings, X, calculate the maximum log-likelihood per character for a unigram model over characters (including STOP symbol)
	"""
	c = Counter(x for s in X for x in s)
	c.update("end" for s in X)
	n = sum(c.values())
	logp = {x:math.log(c[x]/n) for x in c}
	return sum(c[x]*logp[x] for x in c)/n

	def make_corpus_bigram(C):
	#using newline as "end"
	#C is a list of tasks

	#make one big list of strings
	str_list = [example + '\n' for task in C for example in task]

	#make list of
	head_count = Counter(element[0] for element in str_list)
	head_n = sum(head_count.values())
	head_logp = {x:math.log(head_count[x]/head_n) for x in head_count}

	body_count = Counter(element[i:i+2] for element in str_list for i in range(len(element)-1))
	body_bigram_n = sum(body_count.values())
	#body_count/body_bigram_n gives the joint of a bigram
	body_character_n = Counter(char for element in str_list for char in element)
	body_unigram_n = sum(body_character_n.values())

	body_logp = {x:math.log(body_count[x] / body_bigram_n / body_character_n[x[0]] * body_unigram_n) for x in body_count}

	return {head_logp, body_logp}

	def bigram_corpus_score(X, logp):
	#assume you have a logp dict
	task_ll = 0
	for x in X:
	bigram_list = [x[0]] + [x[i:i+2] for i in range(len(x)-1)] + [x[-1] + '\n']
	bigram_list = [ ''.join(b) if isinstance(b,list) else b
	for b in bigram_list ]

	string_ll = sum(logp.get(bigram, float('-inf')) for bigram in bigram_list) #/(len(x) + 1)

	task_ll += string_ll

	ll = task_ll #/len(X)
	return ll


	class ProbabilisticLikelihoodModel:

	def __init__(self, timeout):
	self.timeout = timeout
	# i need timeout

	def score(self, program, task):
	# need a try, catch here for problems, and for timeouts
	# can copy task.py for the timeout structure
	try:
	def timeoutCallBack(_1, _2): raise EvaluationTimeout()
	signal.signal(signal.SIGVTALRM, timeoutCallBack)
	signal.setitimer(signal.ITIMER_VIRTUAL, self.timeout)
	try:
	string_pregex = program.evaluate([])
	# if 'left_paren' in program.show(False):
	#eprint("string_pregex:", string_pregex)
	#eprint("string_pregex:", string_pregex)
	preg = string_pregex # pregex.create(string_pregex)
	except IndexError:
	# free variable
	return False, NEGATIVEINFINITY
	except Exception as e:
	eprint("Exception during evaluation:", e)
	if "Attempt to evaluate fragment variable" in e:
	eprint("program (bc fragment error)", program)
	return False, NEGATIVEINFINITY

	#tries and catches

	# include prior somehow
	# right now, just summing up log likelihoods. IDK if this is correct.
	# also not using prior at all.

	cum_ll = 0

	example_list = [example[1] for example in task.examples]
	c_example_list = Counter(example_list)

	for c_example in c_example_list:
	#might want a try, except around the following line:

	try:
	#eprint("about to match", program)
	#print("preg:", preg)
	ll = preg.match(c_example)
	#eprint("completed match", ll, program)
	except ValueError as e:
	eprint("ValueError:", e)
	ll = float('-inf')

	#eprint("pregex:", string_pregex)
	#eprint("example[1]", example[1])

	if ll == float('-inf'):
	return False, NEGATIVEINFINITY
	else:
	#ll_per_char = ll/float(len(example[1]))
	#cum_ll_per_char += ll_per_char

	cum_ll += c_example_list[c_example] * ll

	#normalized_cum_ll_per_char = cum_ll_per_char/float(len(task.examples))
	#avg_char_num = sum([len(example[1]) for example in task.examples])/float(len(task.examples))

	#cutoff_ll = regex_plus_bound(example_list)

	normalized_cum_ll = cum_ll/ float(sum([len(example) for example in example_list]))



	#TODO: change the way normalized_cum_ll is calculated
	#TODO: refactor to pass in bigram_model, and others
	#TODO: refactor to do 95% certainty thing josh wants
	success = normalized_cum_ll > task.ll_cutoff



	#eprint("cutoff_ll:", cutoff_ll, ", norm_cum_ll:", normalized_cum_ll)

	return success, normalized_cum_ll

	except EvaluationTimeout:
	eprint("Timed out while evaluating", program)
	return False, NEGATIVEINFINITY
	finally:
	signal.signal(signal.SIGVTALRM, lambda *_: None)
	signal.setitimer(signal.ITIMER_VIRTUAL, 0)


	try:
	import torch
	import torch.nn as nn
	import torch.nn.functional as F
	from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence
	from torch.autograd import Variable

	class FeatureDiscriminatorLikelihoodModel(nn.Module):
	def __init__(self, tasks, featureExtractor,
	successCutoff=0.6, H=8, trainingSuccessRatio=0.5):
	super(FeatureDiscriminatorLikelihoodModel, self).__init__()
	self.extract = featureExtractor
	self.successCutoff = successCutoff
	self.trainingSuccessRatio = trainingSuccessRatio

	self.W = nn.Linear(featureExtractor.outputDimensionality, H)
	self.output = nn.Linear(H, 1)

	# training on initialization
	self.train(tasks)

	def forward(self, examples):
	"""
	Examples is a list of feature sets corresponding to a particular example.
	Output in [0,1] whether all examples correspond to the same program
	"""
	assert all(
	len(x) == self.extract.outputDimensionality for x in examples)
	examples = [F.tanh(self.W(ex)) for ex in examples]
	maxed, _ = torch.max(torch.stack(examples), dim=0)
	return F.sigmoid(self.output(maxed))

	def train(self, tasks, steps=400):
	# list of list of features for each example in each task
	optimizer = torch.optim.Adam(self.parameters())
	with timing("Trained discriminator"):
	losses = []
	for i in range(steps):
	self.zero_grad()
	if random.random() <= self.trainingSuccessRatio:
	# success
	t = random.choice(tasks)
	features = [self.extract.featuresOfTask(
	Task(t.name, t.request, [ex], t.features))
	for ex in t.examples]
	loss = (self(features) - 1.0)**2
	else:
	# fail
	t1, t2 = random.sample(tasks, 2)
	features1 = [self.extract.featuresOfTask(
	Task(t1.name, t1.request, [ex], t1.features))
	for ex in t1.examples[:len(t1.examples) / 2]]
	features2 = [self.extract.featuresOfTask(
	Task(t2.name, t2.request, [ex], t2.features))
	for ex in t2.examples[len(t2.examples) / 2:]]
	features = features1 + features2
	loss = self(features)**2

	loss.backward()
	optimizer.step()
	losses.append(loss.data[0])
	if not i % 50:
	eprint(
	"Discriminator Epoch",
	i,
	"Loss",
	sum(losses) /
	len(losses))
	gc.collect()

	def score(self, program, task):
	taskFeatures = self.extract.featuresOfTask(task)
	progFeatures = self.extract.featuresOfProgram(
	program, task.request)
	likelihood = self([taskFeatures] + [progFeatures])
	likelihood = float(likelihood)
	return likelihood > self.successCutoff, log(likelihood)
	except ImportError:
	pass


	if __name__=="__main__":

	arr = ['MAM.OSBS.2014.06', 'MAM.OSBS.2013.07', 'MAM.OSBS.2013.09', 'MAM.OSBS.2014.05', 'MAM.OSBS.2014.11']
	stems = longest_common_substr(arr)
	print(stems)