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));
}
