private static Result <Grammar> CompileGrammar()
{
return(DSLCompiler.
Compile(new CompilerOptions()
{
InputGrammarText = File.ReadAllText(GrammarPath),
References = CompilerReference.FromAssemblyFiles(typeof(Semantics).GetTypeInfo().Assembly)
}));
}
public static void Main(string[] args)
{
var parseResult = DSLCompiler.ParseGrammarFromFile("sorta.grammar");
foreach (var d in parseResult.Diagnostics)
{
System.Console.WriteLine(d);
}
if (parseResult.Value == null)
{
Console.WriteLine("Failed to load grammar (see errors above)");
return;
}
//---------------------------------------------------------------------------------
var grammar = parseResult.Value;
Console.WriteLine("sucessfuly loaded: " + grammar.Name + "\n");
//---------------------------------------------------------------------------------
{
ProgramNode p = ProgramNode.Parse("Length(x)", grammar, ASTSerializationFormat.HumanReadable);
var inp = new Tuple <string, string>("aaa", "aa");
State input = State.Create(grammar.InputSymbol, inp);
Console.WriteLine(p.Invoke(input));
}
{
/*
* ProgramNode p = ProgramNode.Parse("FirstIndexOf(x, 'a')", grammar, ASTSerializationFormat.HumanReadable);
* var inp = new Tuple<string, string>("aaa", "aa");
* State input = State.Create(grammar.InputSymbol, inp);
* Console.WriteLine(p.Invoke(input));
*/
}
//---------------------------------------------------------------------------------
var g = grammar;
var l = new sorta.Learning.Learners(g);
// simple length comparisons
Print(Learn(g, l, ex("aab", "bb", Order.Greater)));
Print(Learn(g, l, ex("aab", "bb", Order.Less)));
Print(Learn(g, l, ex("bb", "aab", Order.Greater)));
//
Print(Learn(g, l, ex("aab", "bb", Order.Less), ex("bb", "aab", Order.Greater)));
// cannot be solved by length alone
Print(Learn(g, l, ex("aab", "bb", Order.Greater), ex("bb", "aab", Order.Greater)));
// sort by first character
Print(Learn(g, l, ex("Neda Cerise", "Amit Willy", Order.Greater)));
Print(g, "Oliver Mirele", "Neda Cerise", Learn(g, l, ex("Neda Cerise", "Amit Willy", Order.Greater), ex("Oliver Mirele", "Amit Willy", Order.Greater)));
Print(Learn(g, l, ex("Neda Cerise", "Amit Willy", Order.Greater), ex("Oliver Mirele", "Amit Willy", Order.Greater), ex("Oliver Mirele", "Neda Cerise", Order.Greater)));
Print(Learn(g, l, ex("Neda Cerise", "Amit Willy", Order.Greater), ex("Oliver Mirele", "Amit Willy", Order.Greater), ex("Oliver Mirele", "Neda Cerise", Order.Less)));
}
public Refazer4Python(string pathToGrammar = @"..\..\..\Tutor\synthesis\", string pathToDslLib = @"..\..\..\Tutor\bin\debug")
{
_pathToGrammar = pathToGrammar;
_pathToDslLib = pathToDslLib;
Grammar = DSLCompiler.LoadGrammarFromFile(pathToGrammar + @"Transformation.grammar",
libraryPaths: new[] { pathToDslLib });
_prose = new SynthesisEngine(Grammar.Value,
new SynthesisEngine.Config {
LogListener = new LogListener()
});
}
public void TestSubstringProgram()
{
var grammar = DSLCompiler.LoadGrammarFromFile("../../../substring.grammar");
printGrammar(grammar);
var program = grammar.Value.ParseAST("Substring(x, AbsPos(7), AbsPos(15))", ASTSerializationFormat.HumanReadable);
var input = State.Create(grammar.Value.InputSymbol, "Bjoern Hartmann");
var output = program.Invoke(input) as string;
Assert.AreEqual("Hartmann", output);
}
static Grammar getGrammar()
{
var g = DSLCompiler.Compile(new CompilerOptions
{
InputGrammarText = File.ReadAllText("SExp.grammar"),
References = CompilerReference.FromAssemblyFiles(
typeof(SExpProgram).GetTypeInfo().Assembly,
typeof(Semantics.SExp).GetTypeInfo().Assembly,
typeof(Semantics.Semantics).GetTypeInfo().Assembly,
typeof(Learning.RankingScore).GetTypeInfo().Assembly)
});
return(g.Value);
}
public void TestLearnStall()
{
var grammar = DSLCompiler.LoadGrammarFromFile("../../../ProseDSLModels.grammar");
printGrammar(grammar);
SynthesisEngine prose = new SynthesisEngine(grammar.Value);
//{30.3, -8.9, -19.0, -2.4};
/*
* double[] inp1 = new double[4] {10.9, 15.0, -14.5, 12.3};
* double[] out1 = stall(inp1);
* var input1 = State.Create(grammar.Value.InputSymbol, inp1);
* double[] inp2 = new double[4] {30.3, -8.9, -19.0, -2.4};
* double[] out2 = stall(inp1);
* var input2 = State.Create(grammar.Value.InputSymbol, inp1);
* var examples = new Dictionary<State, object> { { input1, out1 }, { input2, out2 }};
*/
double[] inp1 = new double[4] {
10.9, 15.0, -14.5, 12.3
};
double[] out1 = stall(inp1);
var input = State.Create(grammar.Value.InputSymbol, inp1);
var examples = new Dictionary <State, object> {
{ input, out1 }
};
var spec = new ExampleSpec(examples);
var learnedSet = prose.LearnGrammar(spec);
var output = (double[])learnedSet.RealizedPrograms.First().Invoke(input);
stdoutprogram(learnedSet.RealizedPrograms.First().ToString(), "Stall");
TestContext.WriteLine("Running random exmaples for Stall");
//test 1000 random examples
for (int i = 0; i < 1000; ++i)
{
var iTmp = genRnd();
var inpTmp = State.Create(grammar.Value.InputSymbol, iTmp);
var oTmp = stall(iTmp);
var outTmp = (double[])learnedSet.RealizedPrograms.First().Invoke(inpTmp);
TestContext.WriteLine("Excpt [{0}]", string.Join(", ", oTmp));
TestContext.WriteLine("Actul [{0}]", string.Join(", ", outTmp));
Assert.AreEqual(oTmp[0], outTmp[0], 0.001d);
Assert.AreEqual(oTmp[1], outTmp[1], 0.001d);
Assert.AreEqual(oTmp[2], outTmp[2], 0.001d);
Assert.AreEqual(oTmp[3], outTmp[3], 0.001d);
}
}
private LanguageGrammar()
{
var options = new CompilerOptions
{
InputGrammarText = GrammarContent,
References = CompilerReference.FromAssemblyFiles(
typeof(Semantics).GetTypeInfo().Assembly,
typeof(Microsoft.ProgramSynthesis.Wrangling.Tree.Node).GetTypeInfo().Assembly)
};
Result <Grammar> compile = DSLCompiler.Compile(options);
Grammar = compile.Value;
}
/// <summary>
/// To load the grammar file
/// </summary>
/// <param name="grammarFile">Location of the grammar file</param>
/// <returns></returns>
public static Grammar LoadGrammar(string grammarFile)
{
var compilationResult = DSLCompiler.ParseGrammarFromFile(grammarFile);
if (compilationResult.HasErrors)
{
WriteColored(ConsoleColor.Magenta, compilationResult.TraceDiagnostics);
throw new Exception(compilationResult.Exception.InnerException.Message);
}
if (compilationResult.Diagnostics.Count > 0)
{
WriteColored(ConsoleColor.Yellow, compilationResult.TraceDiagnostics);
}
return(compilationResult.Value);
}
private static Grammar LoadGrammar(string file, IReadOnlyList <CompilerReference> assemblyReferences)
{
var compilationResult = DSLCompiler.Compile(new CompilerOptions()
{
InputGrammarText = File.ReadAllText(file),
References = assemblyReferences
});
if (compilationResult.HasErrors)
{
compilationResult.TraceDiagnostics();
return(null);
}
return(compilationResult.Value);
}
public SubmissionFixer(string pathToGrammar = @"..\..\..\Tutor\synthesis\", string pathToDslLib = @"..\..\Tutor\bin\debug")
{
ProsePrograms = new List <IEnumerable <ProgramNode> >();
UsedPrograms = new Dictionary <string, int>();
if (pathToDslLib == null)
{
pathToDslLib = ".";
}
if (pathToGrammar == null)
{
pathToGrammar = "../../../Tutor/synthesis/";
}
grammar =
DSLCompiler.LoadGrammarFromFile(pathToGrammar + @"Transformation.grammar",
libraryPaths: new[] { pathToDslLib });
}
public void TestLearnStringTransformation()
{
var grammar = DSLCompiler.LoadGrammarFromFile("../../../substring.grammar");
printGrammar(grammar);
SynthesisEngine prose = new SynthesisEngine(grammar.Value);
var input = State.Create(grammar.Value.InputSymbol, "Bjoern Hartmann");
var examples = new Dictionary <State, object> {
{ input, "B. Hartmann" }
};
var spec = new ExampleSpec(examples);
var learnedSet = prose.LearnGrammar(spec);
var output = learnedSet.RealizedPrograms.First().Invoke(input) as string;
Assert.AreEqual("Hartmann, B.", output);
}
public void testAvgVal()
{
var grammar = DSLCompiler.LoadGrammarFromFile("../../../ProseDSLModels.grammar");
printGrammar(grammar);
var ast = grammar.Value.ParseAST("stall(stall(stall(div(add(x), len(x))))))", ASTSerializationFormat.HumanReadable);
double[] numbers = new double[4] {
10.9, 15.0, -14.5, 12.3
};
var input = State.Create(grammar.Value.InputSymbol, numbers);
var output = (double[])ast.Invoke(input);
Assert.AreEqual(5.925, output[0], 0.001d);
}
public TransformationsController()
{
const string grammarFileName = @"Prose/Transformations.grammar";
var reader = new StreamReader(PathToFiles + grammarFileName);
var grammar = reader.ReadToEnd();
_grammar = DSLCompiler.Compile(
new CompilerOptions()
{
InputGrammarText = grammar,
References = CompilerReference.FromAssemblyFiles(
typeof(List <int>).GetTypeInfo().Assembly,
typeof(Semantics).GetTypeInfo().Assembly,
typeof(Node).GetTypeInfo().Assembly)
}
);
}
public static Grammar LoadGrammar(string grammarFile, IReadOnlyList <CompilerReference> assemblyReferences)
{
var compilationResult = DSLCompiler.Compile(new CompilerOptions()
{
InputGrammarText = File.ReadAllText(grammarFile),
References = assemblyReferences
});
if (compilationResult.HasErrors)
{
WriteColored(ConsoleColor.Magenta, compilationResult.TraceDiagnostics);
return(null);
}
if (compilationResult.Diagnostics.Count > 0)
{
WriteColored(ConsoleColor.Yellow, compilationResult.TraceDiagnostics);
}
return(compilationResult.Value);
}
public static void Main(string[] args)
{
var parseResult = DSLCompiler.ParseGrammarFromFile("MatrixGrammar.grammar");
parseResult.TraceDiagnostics();
var grammar = parseResult.Value;
Console.WriteLine(grammar.Name);
//var ast = ProgramNode.Parse("matPlus(matPlus(M, M), M))", grammar, ASTSerializationFormat.HumanReadable);
//double[] inp = new double[] { 2, 2, 1, 2, 3, 4 };
System.Random random = new System.Random();
double[] inp = new double[10002];
double[] opt = new double[10002];
inp[0] = 100;
inp[1] = 100;
opt[0] = 100;
opt[1] = 100;
for (int i = 2; i < 10002; i++)
{
double val = random.NextDouble();
inp[i] = val; // NextDouble already returns double from [0,1)
opt[i] = 2 * val;
}
//double[] opt = new double[] { 2, 2, 2, 4, 6, 8 };
var input = State.Create(grammar.InputSymbol, inp);
var spec = new ExampleSpec(new Dictionary <State, object> {
[input] = opt
});
//var engine = new SynthesisEngine(grammar);
var engine = new SynthesisEngine(grammar, new SynthesisEngine.Config
{
Strategies = new ISynthesisStrategy[]
{
new DeductiveSynthesis(new MatrixLogic(grammar)),
}
});
ProgramSet learned = engine.LearnGrammar(spec);
Console.Write(learned.Size);
}
public static void Main(string[] args)
{
var parseResult = DSLCompiler.ParseGrammarFromFile("SortKeySynthesis.grammar");
parseResult.TraceDiagnostics();
var grammar = parseResult.Value;
foreach (var d in parseResult.Diagnostics)
{
System.Console.WriteLine(d);
}
if (grammar == null)
{
Console.WriteLine("Grammar is null");
return;
}
testForwardExecution(grammar);
testLearning(grammar);
}
public void TestLearnDiv()
{
var grammar = DSLCompiler.LoadGrammarFromFile("../../../ProseDSLModels.grammar");
printGrammar(grammar);
SynthesisEngine prose = new SynthesisEngine(grammar.Value);
double[] inp1 = new double[4] {
10.9, 15.0, -14.5, 12.3
};
double[] out1 = new double[4] {
2.725, 0.0, 0.0, 0.0
};
var input = State.Create(grammar.Value.InputSymbol, inp1);
var examples = new Dictionary <State, object> {
{ input, out1 }
};
var spec = new ExampleSpec(examples);
var learnedSet = prose.LearnGrammar(spec);
var output = (double[])learnedSet.RealizedPrograms.First().Invoke(input);
Assert.AreEqual(2.725, output[0], 0.001d);
}
