public void Model_Use_Case()
{
var inputShape = new int[] { 28, 28, 1 };
var numberOfClasses = 10;
var outputShape = new int[] { numberOfClasses };
(var observations, var targets) = CreateArtificialData(inputShape, outputShape, observationCount: 100);
var dataType = DataType.Float;
var device = DeviceDescriptor.UseDefaultDevice();
var random = new Random(232);
Func <CNTKDictionary> weightInit = () => Initializers.GlorotNormal(random.Next());
var biasInit = Initializers.Zero();
// Create the architecture.
var network = Layers.Input(inputShape, dataType)
.Dense(512, weightInit(), biasInit, device, dataType)
.ReLU()
.Dense(numberOfClasses, weightInit(), biasInit, device, dataType)
.Softmax();
// setup input and target variables.
var inputVariable = network.Arguments[0];
var targetVariable = Variable.InputVariable(network.Output.Shape, dataType);
// loss
var lossFunc = Losses.CategoricalCrossEntropy(network.Output, targetVariable);
var metricFunc = Metrics.Accuracy(network.Output, targetVariable);
// setup trainer.
var learner = Learners.MomentumSGD(network.Parameters());
var trainer = CNTKLib.CreateTrainer(network, lossFunc, metricFunc, new LearnerVector {
learner
});
var model = new Model(trainer, network, dataType, device);
// setup name to data.
var nameToData = new Dictionary <string, MemoryMinibatchData>
{
{ "observations", observations },
{ "targets", targets }
};
// setup name to variable
var nameToVariable = new Dictionary <string, Variable>
{
{ "observations", inputVariable },
{ "targets", targetVariable },
};
var trainSource = new MemoryMinibatchSource(nameToVariable, nameToData, seed: 232, randomize: true);
model.Fit(trainSource, batchSize: 8, epochs: 2);
(var loss, var metric) = model.Evaluate(trainSource);
Trace.WriteLine($"Final evaluation - Loss: {loss}, Metric: {metric}");
}
private void GetLearners()
{
var credentials = new BasicAuthenticationCredentials();
credentials.UserName = "******";
credentials.Password = "******";
var l = new Learners(new PICSWeb());
var v = l.SearchAsync("Sha", "Aan", "");
List <DBLearner> dbLearners = null;
string surnameSearchText = EdSearchBarName.Text;
if (string.IsNullOrWhiteSpace(surnameSearchText))
{
dbLearners = Task.Run(() => App.DB.GetLearners()).Result;
}
else
{
dbLearners = Task.Run(() => App.DB.SearchLearnersByName(surnameSearchText)).Result;
}
Learners.Clear();
foreach (DBLearner learner in dbLearners)
{
Learners.Add(learner);
}
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
Learners learners = await db.Learners.FindAsync(id);
db.Learners.Remove(learners);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
static SynthesisEngine getEngine(Grammar grammar)
{
var learners = new Learners(grammar);
return(new SynthesisEngine(grammar, new SynthesisEngine.Config
{
Strategies = new ISynthesisStrategy[]
{
new DeductiveSynthesis(learners),
}
}));
}
public async Task <ActionResult> Edit([Bind(Include = "LearnerID,Province,City,Surbub,Street,ZipCode,Phone,IDNum,Location,BookingDate,Session")] Learners learners)
{
if (ModelState.IsValid)
{
db.Entry(learners).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
// ViewBag.PackageID = new SelectList(db.BookingPackages, "PackageID", "Name", learners.PackageID);
// ViewBag.UserID = new SelectList(db.Users, "UserID", "FirstName", learners.UserID);
return(View(learners));
}
public Learner GetLearner(long ukprn, string learnerIdentifier)
{
var learnerUln = Learners.FirstOrDefault(l => l.LearnerIdentifier == learnerIdentifier)?.Uln;
var learner = Learners.FirstOrDefault(l => l.LearnerIdentifier == learnerIdentifier && l.Ukprn == ukprn);
if (learner == null)
{
learner = GenerateLearner(ukprn, learnerUln ?? 0);
learner.LearnerIdentifier = learnerIdentifier;
Learners.Add(learner);
}
return(learner);
}
// GET: Learners/Details/5
public async Task <ActionResult> Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Learners learners = await db.Learners.FindAsync(id);
if (learners == null)
{
return(HttpNotFound());
}
return(View(learners));
}
public ActionResult Register(Learners _learners)
{
if (ModelState.IsValid)
{
Learners _lear = new Learners();
string result = _lear.InsertRegDetails(_learners);
ViewData["result"] = result;
ModelState.Clear();
return(View());
}
else
{
ModelState.AddModelError(string.Empty, "Could Not Register Learner");
return(View());
}
}
// GET: Learners/Edit/5
public async Task <ActionResult> Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Learners learners = await db.Learners.FindAsync(id);
if (learners == null)
{
return(HttpNotFound());
}
// ViewBag.PackageID = new SelectList(db.BookingPackages, "PackageID", "Name", learners.PackageID);
// ViewBag.UserID = new SelectList(db.Users, "UserID", "FirstName", learners.UserID);
return(View(learners));
}
public void SetAdditionalOptions()
{
var expectedL1Regularization = 0.1;
var expectedL2Regularization = 0.001;
var expectedGradientClippingThreshold = 1.0;
var expectedGradientClippingWithTrauncation = false;
var sut = Learners.SetAdditionalOptions(expectedL1Regularization,
expectedL2Regularization,
expectedGradientClippingThreshold,
expectedGradientClippingWithTrauncation);
Assert.AreEqual(expectedL1Regularization, sut.l1RegularizationWeight);
Assert.AreEqual(expectedL2Regularization, sut.l2RegularizationWeight);
Assert.AreEqual(expectedGradientClippingThreshold, sut.gradientClippingThresholdPerSample);
Assert.AreEqual(expectedGradientClippingWithTrauncation, sut.gradientClippingWithTruncation);
}
public async Task <ActionResult> Create([Bind(Include = "LearnerID,Province,City,Surbub,Street,ZipCode,Phone,IDNum,Location,BookingDate,Session,Names,Email,")] Learners learners)
{
if (ModelState.IsValid)
{
string subject = "Your booking for Learners was successfull";
string message = "This message was sent to " + User.Identity.Name + " ' " + learners.Phone + " ' \n " +
"If it is not yours just ignore or contact us on [email protected] \n \n " +
"Hello you booked for Learners. Your Sessions and Lessons will take place from " + learners.BookingDate + " " +
"\n \n We will be happy to meet you in " + learners.Location + " at " + learners.BookingDate + "\n \n " +
"We hank you \n Lindani DS \n";
/////./Mail ///
/// mail
System.Net.ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls;
MailAddress to = new MailAddress(User.Identity.Name);
MailAddress from = new MailAddress("*****@*****.**");
MailMessage mm = new MailMessage(from, to);
mm.Subject = subject;
mm.Body = message;
mm.IsBodyHtml = false;
SmtpClient smtp = new SmtpClient();
smtp.Host = "smtp.gmail.com";
smtp.Port = 587;
smtp.EnableSsl = true;
NetworkCredential nc = new NetworkCredential("*****@*****.**", "@Dut123456");
smtp.UseDefaultCredentials = false;
smtp.Credentials = nc;
smtp.Send(mm);
learners.Email = User.Identity.Name;
db.Learners.Add(learners);
await db.SaveChangesAsync();
return(RedirectToAction("ThankBooking", "Home"));
}
// ViewBag.PackageID = new SelectList(db.BookingPackages, "PackageID", "Name", learners.PackageID);
// ViewBag.UserID = new SelectList(db.Users, "UserID", "FirstName", learners.UserID);
return(View(learners));
}
private static bool ValidateXmlWithXsd(string xmlUri, string xsdUri)
{
try
{
StringBuilder xmlFileData = new StringBuilder();
XmlReaderSettings xmlSettings = new XmlReaderSettings();
xmlSettings.Schemas = new System.Xml.Schema.XmlSchemaSet();
xmlSettings.ValidationType = ValidationType.Schema;
XmlReader reader = XmlReader.Create(xmlUri, xmlSettings);
using (StreamReader file = new StreamReader(xmlUri))
{
string ln;
while ((ln = file.ReadLine()) != null)
{
xmlFileData.Append(ln);
}
file.Close();
}
XmlSerializer serializer = new XmlSerializer(typeof(Message));
List <Learners> lstLearners;
using (TextReader textReader = new StringReader(xmlFileData.ToString()))
{
Message result = (Message)serializer.Deserialize(textReader);
lstLearners = Learners.CastMessageToLearner(result);
}
// Parse the file.
foreach (var item in lstLearners)
{
item.AddToDatabase();
}
return(true);
}
catch (System.Xml.XmlException ex)
{
return(false);
}
}
public void SGD_L2Regularization_Below_Zero_Throws()
{
Learners.SGD(new List <Parameter>(), l2Regularization: -0.1);
}
public List <Learners> GetLearners()
{
return(Learners.GetLearners());
}
public void SGD_LearningRate_Below_Zero_Throws()
{
Learners.SGD(new List <Parameter>(), learningRate: -0.1);
}
public void SGD_Parameters_Is_Null_Throws()
{
Learners.SGD(null);
}
public void Run()
{
// Prepare data
var baseDataDirectoryPath = @"E:\DataSets\Mnist";
var trainFilePath = Path.Combine(baseDataDirectoryPath, "Train-28x28_cntk_text.txt");
// Define data type and device for the model.
var dataType = DataType.Float;
var device = DeviceDescriptor.UseDefaultDevice();
// Setup initializers
var random = new Random(232);
Func <CNTKDictionary> weightInit = () => Initializers.Xavier(random.Next(), scale: 0.02);
var biasInit = Initializers.Zero();
// Ensure reproducible results with CNTK.
CNTKLib.SetFixedRandomSeed((uint)random.Next());
CNTKLib.ForceDeterministicAlgorithms();
// Setup generator
var ganeratorInputShape = NDShape.CreateNDShape(new int[] { 100 });
var generatorInput = Variable.InputVariable(ganeratorInputShape, dataType);
var generatorNetwork = Generator(generatorInput, weightInit, biasInit, device, dataType);
// Setup discriminator
var discriminatorInputShape = NDShape.CreateNDShape(new int[] { 784 }); // 28 * 28 * 1.
var discriminatorInput = Variable.InputVariable(discriminatorInputShape, dataType);
// scale image input between -1.0 and 1.0.
var discriminatorInputScaled = CNTKLib.Minus(
CNTKLib.ElementTimes(Constant.Scalar(2 * 0.00390625f, device), discriminatorInput),
Constant.Scalar(1.0f, device));
var discriminatorNetwork = Discriminator(discriminatorInputScaled, weightInit, biasInit, device, dataType);
// The discriminator must be used on both the real MNIST images and fake images generated by the generator function.
// One way to represent this in the computational graph is to create a clone of the output of the discriminator function,
// but with substituted inputs. Setting method = share in the clone function ensures that both paths through the discriminator model
// use the same set of parameters.
var discriminatorNetworkFake = discriminatorNetwork
.Clone(ParameterCloningMethod.Share, replacements:
new Dictionary <Variable, Variable>
{
{ discriminatorInputScaled.Output, generatorNetwork.Output },
});
// Create minibatch source for providing the real images.
var imageNameToVariable = new Dictionary <string, Variable> {
{ "features", discriminatorInput }
};
var imageMinibatchSource = CreateMinibatchSource(trainFilePath, imageNameToVariable, randomize: true);
// Create minibatch source for providing the noise.
var noiseNameToVariable = new Dictionary <string, Variable> {
{ "noise", generatorInput }
};
var noiseMinibatchSource = new UniformNoiseMinibatchSource(noiseNameToVariable, min: -1.0f, max: 1.0f, seed: random.Next());
// Combine both sources in the composite minibatch source.
var compositeMinibatchSource = new CompositeMinibatchSource(imageMinibatchSource, noiseMinibatchSource);
// Setup generator loss: 1.0 - C.log(D_fake)
var generatorLossFunc = CNTKLib.Minus(Constant.Scalar(1.0f, device),
CNTKLib.Log(discriminatorNetworkFake));
// Setup discriminator loss: -(C.log(D_real) + C.log(1.0 - D_fake))
var discriminatorLossFunc = CNTKLib.Negate(CNTKLib.Plus(CNTKLib.Log(discriminatorNetwork),
CNTKLib.Log(CNTKLib.Minus(Constant.Scalar(1.0f, device), discriminatorNetworkFake))));
// Create fitters for the training loop.
// Generator uses Adam and discriminator SGD.
// Advice from: https://github.com/soumith/ganhacks
var generatorLearner = Learners.Adam(generatorNetwork.Parameters(),
learningRate: 0.0002, momentum: 0.5, gradientClippingThresholdPerSample: 1.0);
var generatorFitter = CreateFitter(generatorLearner, generatorNetwork, generatorLossFunc, device);
var discriminatorLearner = Learners.SGD(discriminatorNetwork.Parameters(),
learningRate: 0.0002, gradientClippingThresholdPerSample: 1.0);
var discriminatorFitter = CreateFitter(discriminatorLearner, discriminatorNetwork, discriminatorLossFunc, device);
int epochs = 30;
int batchSize = 128;
// Controls how many steps the discriminator takes,
// each time the generator takes 1 step.
// Default from the original paper is 1.
int discriminatorSteps = 1;
var isSweepEnd = false;
for (int epoch = 0; epoch < epochs;)
{
for (int step = 0; step < discriminatorSteps; step++)
{
// Discriminator needs both real images and noise,
// so uses the composite minibatch source.
var minibatchItems = compositeMinibatchSource.GetNextMinibatch(batchSize, device);
isSweepEnd = minibatchItems.isSweepEnd;
discriminatorFitter.FitNextStep(minibatchItems.minibatch, batchSize);
DisposeValues(minibatchItems.minibatch);
}
// Generator only needs noise images,
// so uses the noise minibatch source separately.
var noiseMinibatchItems = noiseMinibatchSource.GetNextMinibatch(batchSize, device);
generatorFitter.FitNextStep(noiseMinibatchItems.minibatch, batchSize);
DisposeValues(noiseMinibatchItems.minibatch);
if (isSweepEnd)
{
var generatorCurrentLoss = generatorFitter.CurrentLoss;
generatorFitter.ResetLossAndMetricAccumulators();
var discriminatorCurrentLoss = discriminatorFitter.CurrentLoss;
discriminatorFitter.ResetLossAndMetricAccumulators();
var traceOutput = $"Epoch: {epoch + 1:000} Generator Loss = {generatorCurrentLoss:F8}, Discriminator Loss = {discriminatorCurrentLoss:F8}";
Trace.WriteLine(traceOutput);
++epoch;
}
}
// Sample 6x6 images from generator.
var samples = 6 * 6;
var batch = noiseMinibatchSource.GetNextMinibatch(samples, device);
var noise = batch.minibatch;
var predictor = new Predictor(generatorNetwork, device);
var images = predictor.PredictNextStep(noise);
var imagesData = images.SelectMany(t => t).ToArray();
// Show examples
var app = new Application();
var window = new PlotWindowBitMap("Generated Images", imagesData, 28, 28, 1, true);
window.Show();
app.Run(window);
}
public void Run()
{
// Prepare data
var baseDataDirectoryPath = @"E:\DataSets\CatsAndDogs";
var mapFiles = PrepareMapFiles(baseDataDirectoryPath);
// Define the input and output shape.
var inputShape = new int[] { 150, 150, 3 };
var numberOfClasses = 2;
var outputShape = new int[] { numberOfClasses };
// Define data type and device for the model.
var dataType = DataType.Float;
var device = DeviceDescriptor.UseDefaultDevice();
// Setup initializers
var random = new Random(232);
Func <CNTKDictionary> weightInit = () => Initializers.GlorotNormal(random.Next());
var biasInit = Initializers.Zero();
// Ensure reproducible results with CNTK.
CNTKLib.SetFixedRandomSeed((uint)random.Next());
CNTKLib.ForceDeterministicAlgorithms();
// Create the architecture.
var network = Layers.Input(inputShape, dataType)
.Conv2D((3, 3), 32, (1, 1), Padding.None, weightInit(), biasInit, device, dataType)
.ReLU()
.MaxPool2D((2, 2), (2, 2), Padding.None)
.Conv2D((3, 3), 64, (1, 1), Padding.None, weightInit(), biasInit, device, dataType)
.ReLU()
.MaxPool2D((2, 2), (2, 2), Padding.None)
.Conv2D((3, 3), 128, (1, 1), Padding.None, weightInit(), biasInit, device, dataType)
.ReLU()
.MaxPool2D((2, 2), (2, 2), Padding.None)
.Conv2D((3, 3), 128, (1, 1), Padding.None, weightInit(), biasInit, device, dataType)
.ReLU()
.MaxPool2D((2, 2), (2, 2), Padding.None)
.Dense(512, weightInit(), biasInit, device, dataType)
.ReLU()
.Dense(numberOfClasses, weightInit(), biasInit, device, dataType)
.Softmax();
// Get input and target variables from network.
var inputVariable = network.Arguments[0];
var targetVariable = Variable.InputVariable(outputShape, dataType);
// setup loss and learner.
var lossFunc = Losses.CategoricalCrossEntropy(network.Output, targetVariable);
var metricFunc = Metrics.Accuracy(network.Output, targetVariable);
// setup trainer.
var learner = Learners.RMSProp(network.Parameters());
var trainer = Trainer.CreateTrainer(network, lossFunc, metricFunc, new List <Learner> {
learner
});
// Create the network.
var model = new Model(trainer, network, dataType, device);
// Write model summary.
Trace.WriteLine(model.Summary());
// Setup minibatch sources.
var featuresName = "features";
var targetsName = "targets";
// setup name to variable map.
var nameToVariable = new Dictionary <string, Variable>
{
{ featuresName, inputVariable },
{ targetsName, targetVariable },
};
var train = CreateMinibatchSource(mapFiles.trainFilePath, featuresName, targetsName,
numberOfClasses, inputShape, augmentation: true);
var trainingSource = new CntkMinibatchSource(train, nameToVariable);
// Notice augmentation is switched off for validation data.
var valid = CreateMinibatchSource(mapFiles.validFilePath, featuresName, targetsName,
numberOfClasses, inputShape, augmentation: false);
var validationSource = new CntkMinibatchSource(valid, nameToVariable);
// Notice augmentation is switched off for test data.
var test = CreateMinibatchSource(mapFiles.testFilePath, featuresName, targetsName,
numberOfClasses, inputShape, augmentation: false);
var testSource = new CntkMinibatchSource(test, nameToVariable);
// Train the model using the training set.
model.Fit(trainMinibatchSource: trainingSource,
epochs: 100, batchSize: 32,
validationMinibatchSource: validationSource);
// Evaluate the model using the test set.
var(loss, metric) = model.Evaluate(testSource);
// Write the test set loss and metric to debug output.
Trace.WriteLine($"Test set - Loss: {loss}, Metric: {metric}");
// Save model.
model.Network.Save("cats_and_dogs_small_2.cntk");
}
public void Run()
{
// Prepare data
var baseDataDirectoryPath = @"E:\DataSets\Mnist";
var trainFilePath = Path.Combine(baseDataDirectoryPath, "Train-28x28_cntk_text.txt");
var testFilePath = Path.Combine(baseDataDirectoryPath, "Test-28x28_cntk_text.txt");
// Define the input and output shape.
var inputShape = new int[] { 28, 28, 1 };
var numberOfClasses = 10;
var outputShape = new int[] { numberOfClasses };
// Define data type and device for the model.
var dataType = DataType.Float;
var device = DeviceDescriptor.UseDefaultDevice();
// Setup initializers
var random = new Random(232);
Func <CNTKDictionary> weightInit = () => Initializers.GlorotNormal(random.Next());
var biasInit = Initializers.Zero();
// Ensure reproducible results with CNTK.
CNTKLib.SetFixedRandomSeed((uint)random.Next());
CNTKLib.ForceDeterministicAlgorithms();
// Create the architecture.
var input = Layers.Input(inputShape, dataType);
// scale input between 0 and 1.
var scaledInput = CNTKLib.ElementTimes(Constant.Scalar(0.00390625f, device), input);
var network = scaledInput
.Conv2D((3, 3), 32, (1, 1), Padding.None, weightInit(), biasInit, device, dataType)
.ReLU()
.MaxPool2D((2, 2), (2, 2), Padding.None)
.Conv2D((3, 3), 32, (1, 1), Padding.None, weightInit(), biasInit, device, dataType)
.ReLU()
.MaxPool2D((2, 2), (2, 2), Padding.None)
.Conv2D((3, 3), 32, (1, 1), Padding.None, weightInit(), biasInit, device, dataType)
.ReLU()
.Dense(64, weightInit(), biasInit, device, dataType)
.ReLU()
.Dense(numberOfClasses, weightInit(), biasInit, device, dataType)
.Softmax();
// Get input and target variables from network.
var inputVariable = network.Arguments[0];
var targetVariable = Variable.InputVariable(outputShape, dataType);
// setup loss and learner.
var lossFunc = Losses.CategoricalCrossEntropy(network.Output, targetVariable);
var metricFunc = Metrics.Accuracy(network.Output, targetVariable);
// setup trainer.
var learner = Learners.RMSProp(network.Parameters());
var trainer = Trainer.CreateTrainer(network, lossFunc, metricFunc, new List <Learner> {
learner
});
// Create the network.
var model = new Model(trainer, network, dataType, device);
// Write model summary.
Trace.WriteLine(model.Summary());
// Setup minibatch sources.
// Network will be trained using the training set,
// and tested using the test set.
// setup name to variable map.
var nameToVariable = new Dictionary <string, Variable>
{
{ "features", inputVariable },
{ "labels", targetVariable },
};
// The order of the training data is randomize.
var train = CreateMinibatchSource(trainFilePath, nameToVariable, randomize: true);
var trainingSource = new CntkMinibatchSource(train, nameToVariable);
// Notice randomization is switched off for test data.
var test = CreateMinibatchSource(testFilePath, nameToVariable, randomize: false);
var testSource = new CntkMinibatchSource(test, nameToVariable);
// Train the model using the training set.
model.Fit(trainingSource, epochs: 5, batchSize: 64);
// Evaluate the model using the test set.
var(loss, metric) = model.Evaluate(testSource);
// Write the test set loss and metric to debug output.
Trace.WriteLine($"Test set - Loss: {loss}, Metric: {metric}");
}
public void Run()
{
// Prepare data
var baseDataDirectoryPath = @"E:\DataSets\Imdb";
var trainFilePath = Path.Combine(baseDataDirectoryPath, "imdb_sparse_train_50w.txt");
var testFilePath = Path.Combine(baseDataDirectoryPath, "imdb_sparse_test_50w.txt");
// Define the input and output shape.
var inputShape = new int[] { 129888 + 4 }; // Number distinct input words + offset for one-hot, sparse
var numberOfClasses = 2;
var outputShape = new int[] { numberOfClasses };
// Define data type and device for the model.
var dataType = DataType.Float;
var device = DeviceDescriptor.UseDefaultDevice();
// Setup initializers
var random = new Random(232);
Func <CNTKDictionary> weightInit = () => Initializers.GlorotNormal(random.Next());
var biasInit = Initializers.Zero();
// Ensure reproducible results with CNTK.
CNTKLib.SetFixedRandomSeed((uint)random.Next());
CNTKLib.ForceDeterministicAlgorithms();
// Create the architecture.
var network = Layers.Input(inputShape, dataType, isSparse: true)
.Embedding(32, weightInit(), dataType, device)
.LSTMStack(32, 1, weightInit(), false, device, dataType)
.Dense(numberOfClasses, weightInit(), biasInit, device, dataType)
.Softmax();
// Since we are processing sequence data,
// wrap network in sequenceLast.
network = CNTKLib.SequenceLast(network);
// Get input and target variables from network.
var inputVariable = network.Arguments[0];
var targetVariable = Variable.InputVariable(outputShape, dataType,
dynamicAxes: new List <Axis>()
{
Axis.DefaultBatchAxis()
},
isSparse: false);
// setup loss and learner.
var lossFunc = Losses.CategoricalCrossEntropy(network.Output, targetVariable);
var metricFunc = Metrics.Accuracy(network.Output, targetVariable);
// setup trainer.
var learner = Learners.Adam(network.Parameters());
var trainer = Trainer.CreateTrainer(network, lossFunc, metricFunc, new List <Learner> {
learner
});
// Create the network.
var model = new Model(trainer, network, dataType, device);
// Write model summary.
Trace.WriteLine(model.Summary());
// Setup minibatch sources.
// Network will be trained using the training set,
// and tested using the test set.
var featuresName = "x";
var targetsName = "y";
// setup name to variable map.
var nameToVariable = new Dictionary <string, Variable>
{
{ featuresName, inputVariable },
{ targetsName, targetVariable },
};
// The order of the training data is randomize.
var train = CreateMinibatchSource(trainFilePath, featuresName, targetsName,
numberOfClasses, inputShape, randomize: true);
var trainingSource = new CntkMinibatchSource(train, nameToVariable);
// Notice randomization is switched off for test data.
var test = CreateMinibatchSource(testFilePath, featuresName, targetsName,
numberOfClasses, inputShape, randomize: false);
var testSource = new CntkMinibatchSource(test, nameToVariable);
// Train the model using the training set.
var history = model.Fit(trainingSource, epochs: 100, batchSize: 512,
validationMinibatchSource: testSource);
// Trace loss and validation history
TraceLossValidationHistory(history);
// Evaluate the model using the test set.
var(loss, metric) = model.Evaluate(testSource);
// Write the test set loss and metric to debug output.
Trace.WriteLine($"Test set - Loss: {loss}, Metric: {metric}");
// Write first ten predictions
var predictions = model.Predict(testSource)
.Take(10);
// Use tensor data directly, since only 1 element pr. sample.
Trace.WriteLine($"Predictions: [{string.Join(", ", predictions.Select(p => p.First()))}]");
}
private static int RecordLearner(Learners learners)
{
return(learners.AddToDatabase());
}
//[TestMethod]
public void Fitter_Loop()
{
var inputShape = new int[] { 28, 28, 1 };
var numberOfClasses = 10;
var outputShape = new int[] { numberOfClasses };
(var observations, var targets) = CreateArtificialData(inputShape, outputShape, observationCount: 10000);
var dataType = DataType.Float;
var device = DeviceDescriptor.UseDefaultDevice();
var random = new Random(232);
Func <CNTKDictionary> weightInit = () => Initializers.GlorotNormal(random.Next());
var biasInit = Initializers.Zero();
// Create the architecture.
var network = Layers.Input(inputShape, dataType)
.Dense(512, weightInit(), biasInit, device, dataType)
.ReLU()
.Dense(numberOfClasses, weightInit(), biasInit, device, dataType)
.Softmax();
// setup input and target variables.
var inputVariable = network.Arguments[0];
var targetVariable = Variable.InputVariable(network.Output.Shape, dataType);
// loss
var loss = Losses.CategoricalCrossEntropy(network.Output, targetVariable);
var metric = Metrics.Accuracy(network.Output, targetVariable);
// setup trainer.
var learner = Learners.MomentumSGD(network.Parameters());
var trainer = CNTKLib.CreateTrainer(network, loss, metric, new LearnerVector {
learner
});
// data names
var observationsName = "observations";
var targetsName = "targets";
// setup name to variable map.
var nameToVariable = new Dictionary <string, Variable>
{
{ observationsName, inputVariable },
{ targetsName, targetVariable },
};
// setup name to data map.
var nameToData = new Dictionary <string, MemoryMinibatchData>
{
{ observationsName, observations },
{ targetsName, targets }
};
var minibatchSource = new MemoryMinibatchSource(nameToVariable, nameToData, seed: 232, randomize: true);
// setup Fitter
var fitter = new Fitter(trainer, device);
// variables for training loop.
var inputMap = new Dictionary <Variable, Value>();
var epochs = 10;
int batchSize = 32;
for (int epoch = 0; epoch < epochs;)
{
var(minibatch, isSweepEnd) = minibatchSource.GetNextMinibatch(batchSize, device);
fitter.FitNextStep(minibatch, batchSize);
if (isSweepEnd)
{
var currentLoss = fitter.CurrentLoss;
var currentMetric = fitter.CurrentMetric;
fitter.ResetLossAndMetricAccumulators();
var traceOutput = $"Epoch: {epoch + 1:000} Loss = {currentLoss:F8}, Metric = {currentMetric:F8}";
++epoch;
Trace.WriteLine(traceOutput);
}
}
}
public void Run()
{
// Prepare data
var baseDataDirectoryPath = @"E:\DataSets\Mnist";
var trainFilePath = Path.Combine(baseDataDirectoryPath, "Train-28x28_cntk_text.txt");
// Define data type and device for the model.
var dataType = DataType.Float;
var device = DeviceDescriptor.UseDefaultDevice();
// Setup initializers
var random = new Random(232);
Func <CNTKDictionary> weightInit = () => Initializers.GlorotUniform(random.Next());
var biasInit = Initializers.Zero();
// Ensure reproducible results with CNTK.
CNTKLib.SetFixedRandomSeed((uint)random.Next());
CNTKLib.ForceDeterministicAlgorithms();
// Setup input dimensions and variables.
var inputShape = NDShape.CreateNDShape(new int[] { 28, 28, 1 });
var InputVariable = Variable.InputVariable(inputShape, dataType);
var scaledInputVariable = CNTKLib.ElementTimes(Constant.Scalar(0.00390625f, device), InputVariable);
const int latentSpaceSize = 2;
// Setup the encoder, this encodes the input into a mean and variance parameter.
var(mean, logVariance) = Encoder(scaledInputVariable, latentSpaceSize, weightInit, biasInit, device, dataType);
// add latent space sampling. This will draw a latent point using a small random epsilon.
var epsilon = CNTKLib.NormalRandom(new int[] { latentSpaceSize }, dataType);
var latentSpaceSampler = CNTKLib.Plus(mean, CNTKLib.ElementTimes(CNTKLib.Exp(logVariance), epsilon));
// add decoder, this decodes from latent space back to an image.
var encoderDecoderNetwork = Decoder(latentSpaceSampler, weightInit, biasInit, device, dataType);
// Create minibatch source for providing the input images.
var nameToVariable = new Dictionary <string, Variable> {
{ "features", encoderDecoderNetwork.Arguments[0] }
};
var minibatchSource = CreateMinibatchSource(trainFilePath, nameToVariable, randomize: true);
// Reconstruction loss. Forces the decoded samples to match the initial inputs.
var reconstructionLoss = Losses.BinaryCrossEntropy(encoderDecoderNetwork.Output, scaledInputVariable);
// Regularization loss. Helps in learning well-formed latent spaces and reducing overfitting to the training data.
var regularizationLoss = RegularizationLoss(mean, logVariance, dataType);
// Overall loss function. Sum of reconstruction- and regularization loss.
var loss = CNTKLib.Plus(reconstructionLoss, regularizationLoss);
// Setup trainer.
var learner = Learners.Adam(encoderDecoderNetwork.Parameters(), learningRate: 0.001, momentum: 0.9);
var trainer = Trainer.CreateTrainer(encoderDecoderNetwork, loss, loss, new List <Learner> {
learner
});
// Create model.
var model = new Model(trainer, encoderDecoderNetwork, dataType, device);
Trace.WriteLine(model.Summary());
// Train the model.
model.Fit(minibatchSource, batchSize: 16, epochs: 10);
//// Use the decoder to sample 15x15 images across the latent space.
// Image generation only requires use of the decoder part of the network.
// Clone and replace the latentSpaceSampler from training with a new decoder input variable.
var decoderInputVariable = Variable.InputVariable(latentSpaceSampler.Output.Shape, dataType);
var replacements = new Dictionary <Variable, Variable>()
{
{ latentSpaceSampler, decoderInputVariable }
};
var decoder = encoderDecoderNetwork.Clone(ParameterCloningMethod.Freeze, replacements);
// Sample 15x15 samples from the latent space
var minibatch = SampleMinibatchForGrid(device, decoderInputVariable, gridSize: 15);
// Transform from points in latent space to images using the decoder.
var predictor = new Predictor(decoder, device);
var images = predictor.PredictNextStep(minibatch);
var imagesData = images.SelectMany(t => t).ToArray();
// Show examples.
var app = new Application();
var window = new PlotWindowBitMap("Generated Images", imagesData, 28, 28, 1, true);
window.Show();
app.Run(window);
}
