public void Generate_Should_Return_DataSet(Type dataSetType) { // Arrange var context = CreateContext(dataSetType); bool success = DataSetGenerator.TryCreateGenerator(context.GenerateType, out var generator); Skip.IfNot(success, $"couldn't create generator for {dataSetType.Name}"); // Act var result = generator.Generate(context); // Assert result.Should().BeOfType(dataSetType); var dataSet = (DataSet)result; dataSet.Tables.Should().NotBeEmpty(); foreach (var table in dataSet.Tables.OfType <DataTable>()) { table.Columns.Should().NotBeEmpty(); table.Rows.Should().NotBeEmpty(); } }
public async Task WillSaveDataGivenDirectly() { var data = DataSetGenerator.Run(DateTime.Today.AddDays(-90), DateTime.Today, "something"); var result = await target.DataSets.Create(DataSet.From("yankee", data)); Assert.Equal(HttpMethod.Put, handler.Request.Method); Assert.Equal(new Uri(baseUri, "data/yankee"), handler.Request.RequestUri); Assert.Equal(JsonConvert.SerializeObject(data), handler.RequestBody); }
public void Generate_Should_Return_DataSet_With_Specified_DataTable_Row_Counts(Type dataSetType) { // Arrange var rowCountByTable = new Dictionary <DataTable, int>(); Func <AutoGenerateContext, int> rowCountFunctor = (AutoGenerateContext ctx) => { var dataTable = (DataTable)ctx.Instance; if (!rowCountByTable.TryGetValue(dataTable, out var count)) { // Because Table2.RecordID is a Primary Key and this Unique, Table2 // must not have more records than Table1 otherwise it is impossible // to have unique values. So, assuming that the dependent tables // come last in the DataSet, we have a decreasing count as we progress // through the list. count = 100 - (rowCountByTable.Count + 1) * 10; rowCountByTable[dataTable] = count; } return(count); }; var context = CreateContext(dataSetType, dataTableRowCountFunctor: rowCountFunctor); bool success = DataSetGenerator.TryCreateGenerator(context.GenerateType, out var generator); Skip.IfNot(success, $"couldn't create generator for {dataSetType.Name}"); // Act var result = generator.Generate(context); // Assert result.Should().BeOfType(dataSetType); var dataSet = (DataSet)result; dataSet.Tables.Should().NotBeEmpty(); foreach (var table in dataSet.Tables.OfType <DataTable>()) { table.Columns.Should().NotBeEmpty(); table.Rows.Should().HaveCount(rowCountByTable[table]); } }
public void TryCreateGenerator_Should_Create_Generator(Type dataSetType, bool shouldSucceed) { // Act bool success = DataSetGenerator.TryCreateGenerator(dataSetType, out var generator); // Assert if (shouldSucceed) { success.Should().BeTrue(); generator.Should().NotBeNull(); } else { success.Should().BeFalse(); } }
public void Generate_Should_Fail_If_Requested_Row_Count_Is_Impossible_Due_To_Foreign_Key_Constraint() { // Arrange var dataSetType = typeof(TypedDataSetWithRelations); var rowCountByTable = new Dictionary <DataTable, int>(); Func <AutoGenerateContext, int> rowCountFunctor = (AutoGenerateContext ctx) => { var dataTable = (DataTable)ctx.Instance; if (!rowCountByTable.TryGetValue(dataTable, out var count)) { // Because Table2.RecordID is a Primary Key and this Unique, Table2 // must not have more records than Table1 otherwise it is impossible // to have unique values. So, assuming that the dependent tables // come last in the DataSet, having an increasing count creates an // impossible situation where there aren't enough related records // to produce unique values. count = 100 + (rowCountByTable.Count + 1) * 10; rowCountByTable[dataTable] = count; } return(count); }; var context = CreateContext(dataSetType, dataTableRowCountFunctor: rowCountFunctor); bool success = DataSetGenerator.TryCreateGenerator(context.GenerateType, out var generator); Skip.IfNot(success, $"couldn't create generator for {dataSetType.Name}"); // Act Action action = () => generator.Generate(context); // Assert action.Should().Throw <ArgumentException>() .Which.Message.Should().StartWith("Unable to satisfy the requested row count"); }
static void Main(string[] args) { var priestsDataSet = DataSetGenerator.Priests(); DataNamesMapper <Person> mapper = new DataNamesMapper <Person>(); List <Person> persons = mapper.Map(priestsDataSet.Tables[0]).ToList(); var ranchersDataSet = DataSetGenerator.Ranchers(); persons.AddRange(mapper.Map(ranchersDataSet.Tables[0])); foreach (var person in persons) { Console.WriteLine("First Name: " + person.FirstName + ", Last Name: " + person.LastName + ", Date of Birth: " + person.DateOfBirth.ToShortDateString() + ", Job Title: " + person.JobTitle + ", Nickname: " + person.TakenName + ", Is American: " + person.IsAmerican); } Console.ReadLine(); }
private static IAutoGenerator ResolveGenerator(AutoGenerateContext context) { var type = context.GenerateType; // Need check if the type is an in/out parameter and adjusted accordingly if (type.IsByRef) { type = type.GetElementType(); } // Check if an expando object needs to generator // This actually means an existing dictionary needs to be populated if (ReflectionHelper.IsExpandoObject(type)) { return(new ExpandoObjectGenerator()); } // Do some type -> generator mapping if (type.IsArray) { type = type.GetElementType(); return(CreateGenericGenerator(typeof(ArrayGenerator <>), type)); } #if !NETSTANDARD1_3 if (DataTableGenerator.TryCreateGenerator(type, out var dataTableGenerator)) { return(dataTableGenerator); } if (DataSetGenerator.TryCreateGenerator(type, out var dataSetGenerator)) { return(dataSetGenerator); } #endif if (ReflectionHelper.IsEnum(type)) { return(CreateGenericGenerator(typeof(EnumGenerator <>), type)); } if (ReflectionHelper.IsGenericType(type)) { // For generic types we need to interrogate the inner types var generics = ReflectionHelper.GetGenericArguments(type); if (ReflectionHelper.IsReadOnlyDictionary(type)) { var keyType = generics.ElementAt(0); var valueType = generics.ElementAt(1); return(CreateGenericGenerator(typeof(ReadOnlyDictionaryGenerator <,>), keyType, valueType)); } if (ReflectionHelper.IsDictionary(type)) { return(CreateDicitonaryGenerator(generics)); } if (ReflectionHelper.IsSet(type)) { type = generics.Single(); return(CreateGenericGenerator(typeof(SetGenerator <>), type)); } if (ReflectionHelper.IsEnumerable(type)) { // If the type has more than one generic use a dictionary (hasn't been resolved by dictionary check above) // Example is a Dictionary<T, U>.KeyCollection if (generics.Count() == 2) { return(CreateDicitonaryGenerator(generics)); } // Otherwise it is a list type type = generics.Single(); return(CreateGenericGenerator(typeof(EnumerableGenerator <>), type)); } if (ReflectionHelper.IsNullable(type)) { type = generics.Single(); return(CreateGenericGenerator(typeof(NullableGenerator <>), type)); } } // Resolve the generator from the type if (Generators.ContainsKey(type)) { return(Generators[type]); } return(CreateGenericGenerator(typeof(TypeGenerator <>), type)); }
private void Go() { var lijstje = DataSetGenerator.Generate(); int size = 500; var img = new Image <Rgba32>(size, size); MLImager.AddPointsToImage(img, lijstje); using (var fs = new FileStream("output.png", FileMode.Create, FileAccess.Write, FileShare.Read)) { img.SaveAsPng(fs); } lijstje.Shuffle(); var testData = lijstje.Take(lijstje.Count / 2).ToList(); var trainData = lijstje.Skip(lijstje.Count / 2).ToList(); foreach (var inp in INPUTS.INPUTSDICT) { state[inp.Key] = false; } state["x"] = true; state["y"] = true; //state["xTimesY"] = true; //var networkShape = new List<int>() { 2, 1, 1 }; var networkShape = new List <int>() { 2, 8, 8, 8, 8, 8, 8, 1 }; var inputIds = new List <string>() { "x", "y" }; var network = NetworkBuilder.BuildNetwork(networkShape, Activations.TANH, Activations.TANH, null, inputIds, false); var w = Stopwatch.StartNew(); for (int i = 0; i < 100000; i++) { foreach (var trainPoint in trainData) { var input = MLHelper.ConstructInput(state, trainPoint.X, trainPoint.Y); NetworkBuilder.ForwardProp(network, input); NetworkBuilder.BackProp(network, trainPoint.Label, Errors.SQUARE); if ((i + 1) % batchSize == 0) { NetworkBuilder.UpdateWeights(network, learningrate, regularizationRate); } } lossTrain = MLHelper.GetLoss(network, state, trainData); lossTest = MLHelper.GetLoss(network, state, testData); Console.WriteLine($"{i}: LossTrain: {lossTrain} LossTest: {lossTest}"); if (w.Elapsed.TotalSeconds > 1) { var img2 = MLImager.GenerateImage(network, state, size); MLImager.AddPointsToImage(img2, lijstje); try { using (var fs = new FileStream("output2.png", FileMode.Create, FileAccess.Write, FileShare.Read)) { img2.SaveAsPng(fs); } } catch (Exception ex) { } w.Restart(); } //for (int y = 1; y < network.Count; y++) //{ // var layer = network[y]; // Console.WriteLine(y); // foreach (var node in layer) // { // var sb = new StringBuilder(); // foreach (var link in node.InputLinks) // { // sb.Append($"Lnk: {link.Weight} "); // } // Console.WriteLine($" {sb.ToString()}"); // } // Console.WriteLine(); //} //double cccc = 0; //foreach (var testPoint in testData) //{ // var input = ConstructInput(testPoint.X, testPoint.Y); // var result = NetworkBuilder.ForwardProp(network, input); // var res = Math.Abs(result - testPoint.Label); // cccc += res; //} //Console.WriteLine($"Res: {cccc}"); } }
internal static IAutoGenerator ResolveGenerator(AutoGenerateContext context) { var type = context.GenerateType; // Need check if the type is an in/out parameter and adjusted accordingly if (type.IsByRef) { type = type.GetElementType(); } // Check if an expando object needs to generator // This actually means an existing dictionary needs to be populated if (ReflectionHelper.IsExpandoObject(type)) { return(new ExpandoObjectGenerator()); } // Do some type -> generator mapping if (type.IsArray) { type = type.GetElementType(); return(CreateGenericGenerator(typeof(ArrayGenerator <>), type)); } #if !NETSTANDARD1_3 if (DataTableGenerator.TryCreateGenerator(type, out var dataTableGenerator)) { return(dataTableGenerator); } if (DataSetGenerator.TryCreateGenerator(type, out var dataSetGenerator)) { return(dataSetGenerator); } #endif if (ReflectionHelper.IsEnum(type)) { return(CreateGenericGenerator(typeof(EnumGenerator <>), type)); } if (ReflectionHelper.IsNullable(type)) { type = ReflectionHelper.GetGenericArguments(type).Single(); return(CreateGenericGenerator(typeof(NullableGenerator <>), type)); } Type genericCollectionType = ReflectionHelper.GetGenericCollectionType(type); if (genericCollectionType != null) { // For generic types we need to interrogate the inner types var generics = ReflectionHelper.GetGenericArguments(genericCollectionType); if (ReflectionHelper.IsReadOnlyDictionary(genericCollectionType)) { var keyType = generics.ElementAt(0); var valueType = generics.ElementAt(1); return(CreateGenericGenerator(typeof(ReadOnlyDictionaryGenerator <,>), keyType, valueType)); } if (ReflectionHelper.IsDictionary(genericCollectionType)) { return(CreateDictionaryGenerator(generics)); } if (ReflectionHelper.IsList(genericCollectionType)) { var elementType = generics.Single(); return(CreateGenericGenerator(typeof(ListGenerator <>), elementType)); } if (ReflectionHelper.IsSet(genericCollectionType)) { var elementType = generics.Single(); return(CreateGenericGenerator(typeof(SetGenerator <>), elementType)); } if (ReflectionHelper.IsCollection(genericCollectionType)) { var elementType = generics.Single(); return(CreateGenericGenerator(typeof(ListGenerator <>), elementType)); } if (ReflectionHelper.IsEnumerable(genericCollectionType)) { // Not a full list type, we can't fake it if it's anything other than // the actual IEnumerable<T> interface itelf. if (type == genericCollectionType) { var elementType = generics.Single(); return(CreateGenericGenerator(typeof(EnumerableGenerator <>), elementType)); } } } // Resolve the generator from the type if (Generators.ContainsKey(type)) { return(Generators[type]); } return(CreateGenericGenerator(typeof(TypeGenerator <>), type)); }