public static void Run() { SimpleCounterTestbench tb = new SimpleCounterTestbench(); DesignContext.Instance.Elaborate(); ///remember start time Start = System.DateTime.Now.Ticks; DesignContext.Instance.Simulate(Cycles * SimpleCounterTestbench.ClockPeriod); #if RUNANALYSIS // Now convert the design to VHDL and embed it into a Xilinx ISE project XilinxProject project = new XilinxProject(@".\hdl_output", "SimpleCounter"); project.PutProperty(EXilinxProjectProperties.DeviceFamily, EDeviceFamily.Spartan3); project.PutProperty(EXilinxProjectProperties.Device, EDevice.xc3s1500l); project.PutProperty(EXilinxProjectProperties.Package, EPackage.fg676); project.PutProperty(EXilinxProjectProperties.SpeedGrade, ESpeedGrade._4); project.PutProperty(EXilinxProjectProperties.PreferredLanguage, EHDL.VHDL); VHDLGenerator codeGen = new VHDLGenerator(); SynthesisEngine.Create(DesignContext.Instance, project).Synthesize(codeGen); project.Save(); #endif }
public static void RunTest() { DesignContext.Reset(); TestHLS_CFlow2_Testbench tb = new TestHLS_CFlow2_Testbench(); DesignContext.Instance.Elaborate(); DesignContext.Instance.Simulate(new Time(100.0, ETimeUnit.us)); DesignContext.Stop(); XilinxIntegration.RegisterIPCores(DesignContext.Instance.Descriptor); DesignContext.Instance.CompleteAnalysis(); XC6VLX75T_FF484 fpga = new XC6VLX75T_FF484() { SpeedGrade = ESpeedGrade._2, TopLevelComponent = tb.DUT }; fpga.Testbenches.Add(tb); fpga.Synthesize(@".\hdl_out_TestHLS_CFlow2", "TestHLS_CFlow2"); var eng = SynthesisEngine.Create( DesignContext.Instance, new DocumentationProject(@".\hdl_out_TestHLS_CFlow2\doc")); eng.Synthesize(new DocumentationGenerator()); }
public void TestLearnSubstringPositiveAbsPosSecOcurrence() { Result <Grammar> grammar = CompileGrammar(); SynthesisEngine prose = ConfigureSynthesis(grammar.Value); State firstInput = State.CreateForExecution(grammar.Value.InputSymbol, "16-Feb-2016"); State secondInput = State.CreateForExecution(grammar.Value.InputSymbol, "14-Jan-2012"); var examples = new Dictionary <State, object> { { firstInput, "16" }, { secondInput, "12" } }; var spec = new ExampleSpec(examples); ProgramSet learnedSet = prose.LearnGrammar(spec); IEnumerable <ProgramNode> programs = learnedSet.RealizedPrograms; ProgramNode firstProgram = programs.First(); var output = firstProgram.Invoke(firstInput) as string; Assert.AreEqual("16", output); output = firstProgram.Invoke(secondInput) as string; Assert.AreEqual("12", output); State differentInput = State.CreateForExecution(grammar.Value.InputSymbol, "15-Apr-1500"); output = programs.First().Invoke(differentInput) as string; Assert.AreEqual("00", output); }
public void TestLearnAdd() { 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 = add(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(), "Add"); Assert.AreEqual(23.7, output[0], 0.001d); TestContext.WriteLine("Running random exmaples for LearnAdd"); //test 1000 random examples for (int i = 0; i < 1000; ++i) { var iTmp = genRnd(); var inpTmp = State.Create(grammar.Value.InputSymbol, iTmp); var oTmp = add(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); } }
public static void Setup() { _grammar = LoadGrammar("TreeLang.grammar", CompilerReference.FromAssemblyFiles( typeof(Microsoft.ProgramSynthesis.Utils.Record).GetTypeInfo().Assembly, typeof(Semantics).GetTypeInfo().Assembly, typeof(SyntaxNode).GetTypeInfo().Assembly)); if (_grammar == null) { Log.Error("Failed to compile TreeLang.grammar."); return; } InputSymbol = _grammar.InputSymbol; _scorer = new RankingScore(_grammar); _engine = new SynthesisEngine(_grammar, new SynthesisEngine.Config { Strategies = new ISynthesisStrategy[] { new PremStrategy(_grammar), }, UseThreads = false }); Log.Debug("Transformer: synthesis engine is setup."); }
public void TestLearnSub() { 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] { 0.0, 4.1, -25.4, 1.4 }; 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(0.0, output[0], 0.001d); Assert.AreEqual(4.1, output[1], 0.001d); Assert.AreEqual(-25.4, output[2], 0.001d); Assert.AreEqual(1.4, output[3], 0.001d); }
public static void RunTest() { DesignContext.Reset(); FixedPointSettings.GlobalDefaultRadix = 10; var tb = new Test_SinCosLUT_Testbench(7, 8, 9, 0); DesignContext.Instance.Elaborate(); DesignContext.Instance.Simulate(new Time(1.0, ETimeUnit.us)); DesignContext.Stop(); //XilinxIntegration.RegisterIPCores(DesignContext.Instance.Descriptor); DesignContext.Instance.CompleteAnalysis(); // Now convert the design to VHDL and embed it into a Xilinx ISE project XilinxProject project = new XilinxProject(@".\hdl_out_Test_SinCosLUT_Testbench", "Test_SinCosLUT_Testbench"); project.PutProperty(EXilinxProjectProperties.DeviceFamily, EDeviceFamily.Virtex6); project.PutProperty(EXilinxProjectProperties.Device, EDevice.xc6vlx240t); project.PutProperty(EXilinxProjectProperties.Package, EPackage.ff1156); project.PutProperty(EXilinxProjectProperties.SpeedGrade, ESpeedGrade._2); project.PutProperty(EXilinxProjectProperties.PreferredLanguage, EHDL.VHDL); project.SetVHDLProfile(); project.TwinProject = new ModelsimProject(@".\hdl_out_Test_SinCosLUT_Testbench", "Test_SinCosLUT_Testbench"); VHDLGenerator codeGen = new VHDLGenerator(); SynthesisEngine.Create(DesignContext.Instance, project).Synthesize(tb, codeGen); project.Save(); }
private static void Main(string[] args) { _prose = ConfigureSynthesis(); var menu = @"Select one of the options: 1 - provide training task 2 - run top synthesized program on test 3 - exit"; var option = 0; while (option != 3) { Console.Out.WriteLine(menu); try { option = short.Parse(Console.ReadLine()); } catch (Exception) { Console.Out.WriteLine("Invalid option. Try again."); continue; } RunOption(option); } }
static void Main(string[] args) { Testbench tb = new Testbench(); DesignContext.Instance.Elaborate(); DesignContext.Instance.Simulate(101 * Testbench.ClockPeriod); // Now convert the design to VHDL and embed it into a Xilinx ISE project XilinxProject project_SC = new XilinxProject(@".\SystemC_output", "SimpleCounter"); project_SC.PutProperty(EXilinxProjectProperties.DeviceFamily, EDeviceFamily.Spartan3); project_SC.PutProperty(EXilinxProjectProperties.Device, EDevice.xc3s1500l); project_SC.PutProperty(EXilinxProjectProperties.Package, EPackage.fg676); project_SC.PutProperty(EXilinxProjectProperties.SpeedGrade, ESpeedGrade._4); project_SC.PutProperty(EXilinxProjectProperties.PreferredLanguage, EHDL.VHDL); SystemCGenerator codeGen_SC = new SystemCGenerator(); SynthesisEngine.Create(DesignContext.Instance, project_SC).Synthesize(codeGen_SC); project_SC.Save(); DesignContext.Instance.CompleteAnalysis(); // The actual compilation steps start here. ProcessDescriptor euclid = tb.Descriptor.FindComponent("_gcd").FindProcess("Euclid"); XIL3Function asm = euclid.Implementation.Compile(DefaultInstructionSet.Instance).ToXIL3(); Console.WriteLine(asm); }
public void TestLearnSubstringPositiveAbsPos() { //parse grammar file Result <Grammar> grammar = CompileGrammar(); //configure the prose engine SynthesisEngine prose = ConfigureSynthesis(grammar.Value); //create the example State input = State.CreateForExecution(grammar.Value.InputSymbol, "19-Feb-1960"); var examples = new Dictionary <State, object> { { input, "Feb" } }; var spec = new ExampleSpec(examples); //learn the set of programs that satisfy the spec ProgramSet learnedSet = prose.LearnGrammar(spec); //run the first synthesized program in the same input and check if //the output is correct IEnumerable <ProgramNode> programs = learnedSet.RealizedPrograms; var output = programs.First().Invoke(input) as string; Assert.AreEqual("Feb", output); State differentInput = State.CreateForExecution(grammar.Value.InputSymbol, "15-Jan-2000"); output = programs.First().Invoke(differentInput) as string; Assert.AreEqual("Jan", output); }
public void TestLearnSubstringTwoExamples() { Result <Grammar> grammar = CompileGrammar(); SynthesisEngine prose = ConfigureSynthesis(grammar.Value); State firstInput = State.CreateForExecution(grammar.Value.InputSymbol, "Toby Miller"); State secondInput = State.CreateForExecution(grammar.Value.InputSymbol, "Courtney Lynch"); var examples = new Dictionary <State, object> { { firstInput, "Miller" }, { secondInput, "Lynch" } }; var spec = new ExampleSpec(examples); ProgramSet learnedSet = prose.LearnGrammar(spec); IEnumerable <ProgramNode> programs = learnedSet.RealizedPrograms; var output = programs.First().Invoke(firstInput) as string; Assert.AreEqual("Miller", output); var output2 = programs.First().Invoke(secondInput) as string; Assert.AreEqual("Lynch", output2); State differentInput = State.CreateForExecution(grammar.Value.InputSymbol, "Yun Jasinska"); output = programs.First().Invoke(differentInput) as string; Assert.AreEqual("Jasinska", output); }
public static ProgramNode Learn(Grammar grammar, Spec spec, Feature <double> scorer, DomainLearningLogic witnessFunctions) { var engine = new SynthesisEngine(grammar, new SynthesisEngine.Config { Strategies = new ISynthesisStrategy[] { new EnumerativeSynthesis(), new DeductiveSynthesis(witnessFunctions) }, UseThreads = false, LogListener = new LogListener(), }); ProgramSet consistentPrograms = engine.LearnGrammar(spec); engine.Configuration.LogListener.SaveLogToXML("learning.log.xml"); //foreach (ProgramNode p in consistentPrograms.RealizedPrograms) { // Console.WriteLine(p); //} ProgramNode bestProgram = consistentPrograms.TopK(scorer).FirstOrDefault(); if (bestProgram == null) { WriteColored(ConsoleColor.Red, "No program :("); return(null); } var score = bestProgram.GetFeatureValue(scorer); WriteColored(ConsoleColor.Cyan, $"[score = {score:F3}] {bestProgram}"); return(bestProgram); }
public static ProgramSet Learn(Grammar g, Spec s, string logXmlFilename) { var engine = new SynthesisEngine( grammar: g, config: new SynthesisEngine.Config { Strategies = new ISynthesisStrategy[] { new EnumerativeSynthesis( new EnumerativeSynthesis.Config { MaximalSize = 101 * 101 * 11 * 2 } ), new ComponentBasedSynthesis(null, null, null) }, UseThreads = true, LogListener = new LogListener() }); var consistentPrograms = engine.LearnGrammar(s); engine.Configuration.LogListener.SaveLogToXML(logXmlFilename); return(consistentPrograms); }
private static void Main(string[] args) { _prose = ConfigureSynthesis(); var menu = @"Select one of the options: 1 - provide new example 2 - run top synthesized program on a new input 3 - exit"; var option = 0; while (option != 3) { Console.Out.WriteLine(menu); try { option = short.Parse(Console.ReadLine()); } catch (Exception) { Console.Out.WriteLine("Invalid option. Try again."); continue; } try { RunOption(option); } catch (Exception e) { Console.Error.WriteLine("Something went wrong..."); Console.Error.WriteLine("Exception message: {0}", e.Message); } } }
public static void RunTest() { DesignContext.Reset(); TestDesign1 td1 = new TestDesign1(3, 4); FixedPointSettings.GlobalOverflowMode = EOverflowMode.Wrap; DesignContext.Instance.Elaborate(); DesignContext.Instance.Simulate(20 * TestDesign1.ClockPeriod); // Now convert the design to VHDL and embed it into a Xilinx ISE project XilinxProject project = new XilinxProject(@".\hdl_TestDesign1", "TestDesign1"); project.PutProperty(EXilinxProjectProperties.DeviceFamily, EDeviceFamily.Spartan3); project.PutProperty(EXilinxProjectProperties.Device, EDevice.xc3s1500l); project.PutProperty(EXilinxProjectProperties.Package, EPackage.fg676); project.PutProperty(EXilinxProjectProperties.SpeedGrade, ESpeedGrade._4); project.PutProperty(EXilinxProjectProperties.PreferredLanguage, EHDL.VHDL); VHDLGenerator codeGen = new VHDLGenerator(); SynthesisEngine.Create(DesignContext.Instance, project).Synthesize(codeGen);; project.Save(); DesignContext.Reset(); }
static void Main(string[] args) { Testbench tb = new Testbench(); DesignContext.Instance.Elaborate(); DesignContext.Instance.Simulate(10 * (Design.DataWidth + 3) * Testbench.ClockPeriod); //Console.Read(); #if RUNANALYSIS // Now convert the design to VHDL and embed it into a Xilinx ISE project XilinxProject project = new XilinxProject(@".\hdl_output", "BitSerializer"); project.PutProperty(EXilinxProjectProperties.DeviceFamily, EDeviceFamily.Spartan3); project.PutProperty(EXilinxProjectProperties.Device, EDevice.xc3s1500l); project.PutProperty(EXilinxProjectProperties.Package, EPackage.fg676); project.PutProperty(EXilinxProjectProperties.SpeedGrade, ESpeedGrade._4); project.PutProperty(EXilinxProjectProperties.PreferredLanguage, EHDL.VHDL); VHDLGenerator codeGen = new VHDLGenerator(); SynthesisEngine.Create(DesignContext.Instance, project).Synthesize(codeGen); project.Save(); //// Now convert the design to VHDL and embed it into a Xilinx ISE project //XilinxProject project_SC = new XilinxProject(@".\SystemC_output", "SimpleCounter"); //project_SC.PutProperty(EXilinxProjectProperties.DeviceFamily, EDeviceFamily.Spartan3); //project_SC.PutProperty(EXilinxProjectProperties.Device, EDevice.xc3s1500l); //project_SC.PutProperty(EXilinxProjectProperties.Package, EPackage.fg676); //project_SC.PutProperty(EXilinxProjectProperties.SpeedGrade, ESpeedGrade._4); //project_SC.PutProperty(EXilinxProjectProperties.PreferredLanguage, EHDL.VHDL); //SystemCGenerator codeGen_SC = new SystemCGenerator(); //SynthesisEngine.Create(DesignContext.Instance, project_SC).Synthesize(codeGen_SC); //project_SC.Save(); #endif }
public static void RunTest() { DesignContext.Reset(); TestHLS_PortAccess_Testbench tb = new TestHLS_PortAccess_Testbench(); DesignContext.Instance.Elaborate(); DesignContext.Instance.Simulate(new Time(1.0, ETimeUnit.us)); DesignContext.Stop(); DesignContext.Instance.CompleteAnalysis(); // Now convert the design to VHDL and embed it into a Xilinx ISE project XilinxProject project = new XilinxProject(@".\hdl_out_TestHLS_PortAccess", "TestHLS_PortAccess"); project.PutProperty(EXilinxProjectProperties.DeviceFamily, EDeviceFamily.Virtex6); project.PutProperty(EXilinxProjectProperties.Device, EDevice.xc6vlx240t); project.PutProperty(EXilinxProjectProperties.Package, EPackage.ff1156); project.PutProperty(EXilinxProjectProperties.SpeedGrade, ESpeedGrade._2); project.PutProperty(EXilinxProjectProperties.PreferredLanguage, EHDL.VHDL); project.SetVHDLProfile(); project.SkipIPCoreSynthesis = true; VHDLGenerator codeGen = new VHDLGenerator(); SynthesisEngine.Create(DesignContext.Instance, project).Synthesize(tb, codeGen); project.Save(); }
public static ProgramNode Learn(Grammar grammar, Spec spec) { var engine = new SynthesisEngine(grammar, new SynthesisEngine.Config { UseThreads = false, LogListener = new LogListener(), }); ProgramSet consistentPrograms = engine.LearnGrammar(spec); engine.Configuration.LogListener.SaveLogToXML("learning.log.xml"); //foreach (ProgramNode p in consistentPrograms.RealizedPrograms) { // Console.WriteLine(p); //} ProgramNode bestProgram = consistentPrograms.TopK("Score").FirstOrDefault(); if (bestProgram == null) { WriteColored(ConsoleColor.Red, "No program :("); return(null); } var score = bestProgram["Score"]; WriteColored(ConsoleColor.Cyan, $"[score = {score:F3}] {bestProgram}"); return(bestProgram); }
public static void RunTest() { DesignContext.Reset(); TestHLS_CordicSqrt_Testbench tb = new TestHLS_CordicSqrt_Testbench(); DesignContext.Instance.Elaborate(); DesignContext.Instance.Simulate(new Time(100.0, ETimeUnit.us)); DesignContext.Stop(); XilinxIntegration.RegisterIPCores(DesignContext.Instance.Descriptor); DesignContext.Instance.CompleteAnalysis(); // Now convert the design to VHDL and embed it into a Xilinx ISE project var docproj = new DocumentationProject(@".\hdl_out_TestHLSSqrt_Cordic\doc"); var project = new XilinxProject(@".\hdl_out_TestHLSSqrt_Cordic", "TestHLSSqrt_Cordic"); project.ISEVersion = EISEVersion._13_2; project.PutProperty(EXilinxProjectProperties.DeviceFamily, EDeviceFamily.Virtex6); project.PutProperty(EXilinxProjectProperties.Device, EDevice.xc6vlx240t); project.PutProperty(EXilinxProjectProperties.Package, EPackage.ff1156); project.PutProperty(EXilinxProjectProperties.SpeedGrade, ESpeedGrade._2); project.PutProperty(EXilinxProjectProperties.PreferredLanguage, EHDL.VHDL); project.SetVHDLProfile(); //project.SkipIPCoreSynthesis = true; VHDLGenerator codeGen = new VHDLGenerator(); SynthesisEngine.Create(DesignContext.Instance, project).Synthesize(tb, codeGen); SynthesisEngine.Create(DesignContext.Instance, docproj).Synthesize(new DocumentationGenerator()); project.Save(); docproj.Save(); }
public void TestLearnSubstringOneExample() { Result <Grammar> grammar = CompileGrammar(); SynthesisEngine prose = ConfigureSynthesis(grammar.Value); State input = State.CreateForExecution(grammar.Value.InputSymbol, "Toby Miller"); var examples = new Dictionary <State, object> { { input, "Miller" } }; var spec = new ExampleSpec(examples); var scoreFeature = new RankingScore(grammar.Value); ProgramSet topPrograms = prose.LearnGrammarTopK(spec, scoreFeature, 1, null); ProgramNode topProgram = topPrograms.RealizedPrograms.First(); var x = topProgram.PrintAST(); var y = ProgramNode.Parse(x, grammar.Value); // var y is null. ==> SDK method var se = new ASTSerialization.Serialization(grammar.Value); var xe = se.PrintXML(topProgram); xe.Save(SavedProgramAST); topProgram = se.Parse(xe); // var topProgram is ok. ==> ASTSerialization.Serialization method var output = topProgram.Invoke(input) as string; Assert.AreEqual("Miller", output); State input2 = State.CreateForExecution(grammar.Value.InputSymbol, "Courtney Lynch"); var output2 = topProgram.Invoke(input2) as string; Assert.AreEqual("Lynch", output2); }
/// <summary> /// Entry point of the synthesis strategy, implementing /// `Microsoft.ProgramSynthesis.Learning.Strategies.SynthesisStrategy`. /// </summary> /// <param name="engine">Synthesis engine.</param> /// <param name="task">Learning task, which contains the specification.</param> /// <param name="cancel">Cancellation token.</param> /// <returns></returns> public override Optional <ProgramSet> Learn(SynthesisEngine engine, LearningTask <ExampleSpec> task, CancellationToken cancel) { var spec = task.Spec; var programSet = LearnProgram( PremSpec <TInput, SyntaxNode> .From(spec.Examples, GetInput, o => (SyntaxNode)o)); return(programSet); }
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 static SynthesisEngine ConfigureSynthesis(Grammar grammar) { var witnessFunctions = new WitnessFunctions(grammar); var deductiveSynthesis = new DeductiveSynthesis(witnessFunctions); var synthesisExtrategies = new ISynthesisStrategy[] { deductiveSynthesis }; var synthesisConfig = new SynthesisEngine.Config { Strategies = synthesisExtrategies }; var prose = new SynthesisEngine(grammar, synthesisConfig); return(prose); }
/// <summary> /// Learn <paramref name="k" /> top-ranked Transformation.Text programs for a given set of input-output examples. /// </summary> /// <param name="trainingExamples"> /// The set of input-output examples as a Tuple of the input and the output. /// </param> /// <param name="additionalInputs"> /// The set of additional inputs that do not have output examples, which helps rank learnt programs. /// </param> /// <param name="k">the number of top programs</param> /// <returns>The top-k ranked programs as <see cref="TextTransformationProgram" />s</returns> public static IEnumerable <TextTransformationProgram> LearnTopK(IDictionary <string, string> trainingExamples, IEnumerable <string> additionalInputs = null, int k = 1) { if (trainingExamples == null) { throw new ArgumentNullException(nameof(trainingExamples)); } // Load Transformation.Text grammar Grammar grammar = Language.Grammar; DomainLearningLogic learningLogic = new Witnesses(grammar, // This is currently required as a workaround for a bug. ((RankingScore)Learner.Instance.ScoreFeature).Clone()); // Setup configuration of synthesis process. var engine = new SynthesisEngine(grammar, new SynthesisEngine.Config { // Strategies perform the actual logic of the synthesis process. Strategies = new[] { new DeductiveSynthesis(learningLogic) }, UseThreads = false, CacheSize = int.MaxValue }); // Convert the examples in the format expected by Microsoft.ProgramSynthesis. // Internally, Transformation.Text represents strings as ValueSubstrings to save on // allocating new strings for each substring. // Could also use InputRow.AsState() to construct the input state. Dictionary <State, object> trainExamples = trainingExamples.ToDictionary( t => State.Create(grammar.InputSymbol, new[] { ValueSubstring.Create(t.Key) }), t => (object)ValueSubstring.Create(t.Value)); var spec = new ExampleSpec(trainExamples); // Learn an entire Transformation.Text program (i.e. start at the grammar's start symbol) // for the specification consisting of the examples. // Learn the top-k programs according to the score feature used by Transformation.Text by default. // You could define your own feature on the Transformation.Text grammar to rank programs differently. var task = new LearningTask(grammar.StartSymbol, spec, k, Learner.Instance.ScoreFeature); if (additionalInputs != null) { task.AdditionalInputs = additionalInputs.Select( input => State.Create(grammar.InputSymbol, new[] { ValueSubstring.Create(input) })) .ToList(); } IEnumerable <ProgramNode> topk = engine.Learn(task).RealizedPrograms; // Return the generated programs wraped in a TextTransformationProgram object. return(topk.Select(prog => new TextTransformationProgram(prog))); }
public static void RunTest() { DesignContext.Reset(); Testbench tb = new Testbench(); DesignContext.Instance.Elaborate(); DesignContext.Instance.Simulate(101 * Testbench.ClockPeriod); DesignContext.Instance.CompleteAnalysis(); VHDLGenerator codeGen = new VHDLGenerator(); DocumentationProject proj = new DocumentationProject("./doc"); SynthesisEngine.Create(DesignContext.Instance, proj).Synthesize(codeGen); proj.Save(); }
static ProgramNode learnFromExamples(Grammar grammar, SynthesisEngine engine, RankingScore rankingScores, Dictionary <string, string> exs) { var spec = toSpec(grammar, exs); var ps = engine.LearnGrammar(spec); Console.WriteLine("all programs: " + ps); var best = ps.TopK(rankingScores).First(); Console.WriteLine("best program: " + best); foreach (var ex in spec.Examples) { System.Diagnostics.Debug.Assert(best.Invoke(ex.Key).Equals(ex.Value)); } return(best); }
static void Main(string[] args) { ///default values int cycles = 100; FixedPointSettings.GlobalDefaultRadix = 10; FixedPointSettings.GlobalOverflowMode = EOverflowMode.Fail; ///elaborate SimpleCounterTestbench tb = new SimpleCounterTestbench(); DesignContext.Instance.Elaborate(); ///print out config Console.WriteLine("#cycles: " + cycles); ///simulate DesignContext.Instance.Simulate(cycles * SimpleCounterTestbench.ClockPeriod); ///notify completion Console.WriteLine("Done. [ #cycles = " + cycles + " ]"); #if RUNANALYSIS // Now convert the design to VHDL and embed it into a Xilinx ISE project XilinxProject project = new XilinxProject(@".\hdl_output", "SimpleCounter"); project.PutProperty(EXilinxProjectProperties.DeviceFamily, EDeviceFamily.Spartan3); project.PutProperty(EXilinxProjectProperties.Device, EDevice.xc3s1500l); project.PutProperty(EXilinxProjectProperties.Package, EPackage.fg676); project.PutProperty(EXilinxProjectProperties.SpeedGrade, ESpeedGrade._4); project.PutProperty(EXilinxProjectProperties.PreferredLanguage, EHDL.VHDL); VHDLGenerator codeGen = new VHDLGenerator(); SynthesisEngine.Create(DesignContext.Instance, project).Synthesize(codeGen); project.Save(); //XilinxProject project_SC = new XilinxProject(@".\SystemC_output", "SimpleCounter"); //project_SC.PutProperty(EXilinxProjectProperties.DeviceFamily, EDeviceFamily.Spartan3); //project_SC.PutProperty(EXilinxProjectProperties.Device, EDevice.xc3s1500l); //project_SC.PutProperty(EXilinxProjectProperties.Package, EPackage.fg676); //project_SC.PutProperty(EXilinxProjectProperties.SpeedGrade, ESpeedGrade._4); //project_SC.PutProperty(EXilinxProjectProperties.PreferredLanguage, EHDL.VHDL); //SystemCGenerator codeGen_SC = new SystemCGenerator(); //SynthesisEngine.Create(DesignContext.Instance, project_SC).Synthesize(codeGen_SC); //project_SC.Save(); #endif }
private ProgramSet LearnProgramSet(Spec spec, DomainLearningLogic witnessFunctions) { var engine = new SynthesisEngine(Grammar, new SynthesisEngine.Config { Strategies = new ISynthesisStrategy[] { new EnumerativeSynthesis(), new DeductiveSynthesis(witnessFunctions) }, UseThreads = false, LogListener = new LogListener(), }); ProgramSet consistentPrograms = engine.LearnGrammar(spec); engine.Configuration.LogListener.SaveLogToXML("learning.log.xml"); return(consistentPrograms); }
public IEnumerable <Transformation> LearnTransformations(List <Tuple <string, string> > examples, int numberOfPrograms = 1, string ranking = "specific") { var spec = CreateExampleSpec(examples); //TODO: this is not thread safe. If multiple instances of Refazer are changing //the value of the ranking scores, we can have a problem. RankingScore.ScoreForContext = ranking.Equals("specific") ? 100 : -100; var scoreFeature = new RankingScore(Grammar.Value); DomainLearningLogic learningLogic = new WitnessFunctions(Grammar.Value); _prose = new SynthesisEngine(Grammar.Value, new SynthesisEngine.Config { LogListener = new LogListener(), Strategies = new[] { new DeductiveSynthesis(learningLogic) }, UseThreads = false, CacheSize = int.MaxValue }); var learned = _prose.LearnGrammarTopK(spec, scoreFeature, 1); var uniqueTransformations = new List <ProgramNode>(); //filter repetitive transformations foreach (var programNode in learned) { var exists = false; foreach (var uniqueTransformation in uniqueTransformations) { if (programNode.ToString().Equals(uniqueTransformation.ToString())) { exists = true; break; } } if (!exists) { uniqueTransformations.Add(programNode); } } uniqueTransformations = uniqueTransformations.Count > numberOfPrograms ? uniqueTransformations.GetRange(0, numberOfPrograms) : uniqueTransformations; return(uniqueTransformations.Select(e => new PythonTransformation(e))); }
public static ProgramSet LearnDeductively(Grammar g, Spec s, DomainLearningLogic witness, string logXmlFilename) { var engine = new SynthesisEngine( grammar: g, config: new SynthesisEngine.Config { Strategies = new[] { new DeductiveSynthesis(witness) }, UseThreads = true, LogListener = new LogListener() } ); var consistentPrograms = engine.LearnGrammar(s); engine.Configuration.LogListener.SaveLogToXML(logXmlFilename); return(consistentPrograms); }
static void testSynthesis(Grammar grammar, Dictionary<State, object> examples) { var spec = new ExampleSpec(examples); var engine = new SynthesisEngine(grammar); ProgramSet learned = engine.LearnGrammar(spec); Console.WriteLine("Examples:"); foreach (KeyValuePair<State, object> ex in examples) Console.WriteLine("(Input: " + ex.Key + ", Output: " + ex.Value + ")"); Console.WriteLine("These are the programs that I learned"); foreach (ProgramNode p in learned.RealizedPrograms) { Console.WriteLine(p); foreach (State inputExample in examples.Keys) { Console.WriteLine("Test: (Input: " + inputExample + ", Output: " + p.Invoke(inputExample) + ")"); } } Console.WriteLine(); }
public static ProgramNode Learn(Grammar grammar, Spec spec) { var engine = new SynthesisEngine(grammar, new SynthesisEngine.Config { UseThreads = false, LogListener = new LogListener(), }); ProgramSet consistentPrograms = engine.LearnGrammar(spec); engine.Configuration.LogListener.SaveLogToXML("learning.log.xml"); //foreach (ProgramNode p in consistentPrograms.RealizedPrograms) { // Console.WriteLine(p); //} ProgramNode bestProgram = consistentPrograms.TopK("Score").FirstOrDefault(); if (bestProgram == null) { WriteColored(ConsoleColor.Red, "No program :("); return null; } var score = bestProgram["Score"]; WriteColored(ConsoleColor.Cyan, $"[score = {score:F3}] {bestProgram}"); return bestProgram; }