[ConditionalFact(typeof(Environment), nameof(Environment.Is64BitProcess))] // TensorFlow is 64-bit only
public void TensorFlowTransformCifar()
{
var modelLocation = "cifar_model/frozen_model.pb";
var mlContext = new MLContext(seed: 1, conc: 1);
var tensorFlowModel = TensorFlowUtils.LoadTensorFlowModel(mlContext, modelLocation);
var schema = tensorFlowModel.GetInputSchema();
Assert.True(schema.TryGetColumnIndex("Input", out int column));
var type = (VectorType)schema[column].Type;
var imageHeight = type.Dimensions[0];
var imageWidth = type.Dimensions[1];
var dataFile = GetDataPath("images/images.tsv");
var imageFolder = Path.GetDirectoryName(dataFile);
var data = mlContext.Data.ReadFromTextFile(dataFile,
columns: new[]
{
new TextLoader.Column("ImagePath", DataKind.TX, 0),
new TextLoader.Column("Name", DataKind.TX, 1),
}
);
var pipeEstimator = new ImageLoadingEstimator(mlContext, imageFolder, ("ImagePath", "ImageReal"))
.Append(new ImageResizingEstimator(mlContext, "ImageReal", "ImageCropped", imageWidth, imageHeight))
.Append(new ImagePixelExtractingEstimator(mlContext, "ImageCropped", "Input", interleave: true));
var pixels = pipeEstimator.Fit(data).Transform(data);
IDataView trans = new TensorFlowTransformer(mlContext, tensorFlowModel, "Input", "Output").Transform(pixels);
trans.Schema.TryGetColumnIndex("Output", out int output);
using (var cursor = trans.GetRowCursor(trans.Schema["Output"]))
{
var buffer = default(VBuffer <float>);
var getter = cursor.GetGetter <VBuffer <float> >(output);
var numRows = 0;
while (cursor.MoveNext())
{
getter(ref buffer);
Assert.Equal(10, buffer.Length);
numRows += 1;
}
Assert.Equal(4, numRows);
}
}
public void TestEstimatorSaveLoad()
{
IHostEnvironment env = new MLContext(1);
var dataFile = GetDataPath("images/images.tsv");
var imageFolder = Path.GetDirectoryName(dataFile);
var data = TextLoader.Create(env, new TextLoader.Options()
{
Columns = new[]
{
new TextLoader.Column("ImagePath", DataKind.String, 0),
new TextLoader.Column("Name", DataKind.String, 1),
}
}, new MultiFileSource(dataFile));
var pipe = new ImageLoadingEstimator(env, imageFolder, ("ImageReal", "ImagePath"))
.Append(new ImageResizingEstimator(env, "ImageReal", 100, 100, "ImageReal"))
.Append(new ImagePixelExtractingEstimator(env, "ImagePixels", "ImageReal"))
.Append(new ImageGrayscalingEstimator(env, ("ImageGray", "ImageReal")));
pipe.GetOutputSchema(SchemaShape.Create(data.Schema));
var model = pipe.Fit(data);
var tempPath = Path.GetTempFileName();
using (var file = new SimpleFileHandle(env, tempPath, true, true))
{
using (var fs = file.CreateWriteStream())
ML.Model.Save(model, null, fs);
ITransformer model2;
using (var fs = file.OpenReadStream())
model2 = ML.Model.Load(fs, out var schema);
var transformerChain = model2 as TransformerChain <ITransformer>;
Assert.NotNull(transformerChain);
var newCols = ((ImageLoadingTransformer)transformerChain.First()).Columns;
var oldCols = ((ImageLoadingTransformer)model.First()).Columns;
Assert.True(newCols
.Zip(oldCols, (x, y) => x == y)
.All(x => x));
}
Done();
}
public PredictionEngine <ImageData, ImagePrediction> CreateClassifier()
{
var data = _mlContext.Data.ReadFromEnumerable(new List <ImageData>());
var pipeline = new ImageLoadingEstimator(_mlContext, string.Empty, ("ImageData", "ImagePath"))
.Append(_mlContext.Transforms.Resize("ImageResized", imageWidth: ImageWidth, imageHeight: ImageHeight, inputColumnName: "ImageData"))
.Append(_mlContext.Transforms.ExtractPixels(new ColumnInfo("Red", "ImageResized",
colors: ColorBits.Red, offset: 0.485f * 255, scale: 1 / (0.229f * 255))))
.Append(_mlContext.Transforms.ExtractPixels(new ColumnInfo("Green", "ImageResized",
colors: ColorBits.Green, offset: 0.456f * 255, scale: 1 / (0.224f * 255))))
.Append(_mlContext.Transforms.ExtractPixels(new ColumnInfo("Blue", "ImageResized",
colors: ColorBits.Blue, offset: 0.406f * 255, scale: 1 / (0.225f * 255))))
.Append(_mlContext.Transforms.Concatenate("data", "Red", "Green", "Blue"))
.Append(new OnnxScoringEstimator(_mlContext, new string[] { @"mobilenetv20_output_flatten0_reshape0" }, new string[] { "data" }, _modelFilePath))
.Append(new CustomMappingEstimator <MobileNetOnnxPrediction, ImagePrediction>(_mlContext, contractName: "MobileNetExtractor",
mapAction: (networkResult, prediction) =>
{
prediction.Estimate = networkResult.Output.Max();
prediction.Index = networkResult.Output.ToList().IndexOf(prediction.Estimate);
prediction.Label = _labels[prediction.Index];
}));
//attention code below doesn't work correctly ¯\_(ツ)_/¯
//var pipeline = new ImageLoadingEstimator(_mlContext, string.Empty, ("ImageData", "ImagePath"))
// .Append(new ImageResizingEstimator(_mlContext, "ImageResized", ImageWidth, ImageHeight, "ImageData"))
// .Append(new ImagePixelExtractingEstimator(_mlContext, "Red", "ImageResized", colors: ColorBits.Red, offset: 0.485f * 255, scale: 1 / (0.229f * 255)))
// .Append(new ImagePixelExtractingEstimator(_mlContext, "Green", "ImageResized", colors: ColorBits.Green, offset: 0.456f * 255, scale: 1 / (0.224f * 255)))
// .Append(new ImagePixelExtractingEstimator(_mlContext, "Blue", "ImageResized", colors: ColorBits.Blue, offset: 0.406f * 255, scale: 1 / (0.225f * 255)))
// .Append(new ColumnConcatenatingEstimator(_mlContext, "data", "Red", "Green", "Blue"))
// .Append(new OnnxScoringEstimator(_mlContext, new string[] { @"mobilenetv20_output_flatten0_reshape0" }, new string[] { "data" }, _modelFilePath))
// .Append(new CustomMappingEstimator<MobileNetOnnxPrediction, ImagePrediction>(_mlContext, contractName: "MobileNetExtractor",
// mapAction: (networkResult, prediction) =>
// {
// prediction.Estimate = networkResult.Output.Max();
// prediction.Index = networkResult.Output.ToList().IndexOf(prediction.Estimate);
// prediction.Label = _labels[prediction.Index];
// }));
var transformer = pipeline.Fit(data);
return(transformer.CreatePredictionEngine <ImageData, ImagePrediction>(_mlContext));
}
public PredictionEngine <ImageData, ImagePrediction> CreateClassifier()
{
var data = _mlContext.Data.ReadFromEnumerable(new List <ImageData>());
var pipeline = new ImageLoadingEstimator(_mlContext, string.Empty, ("ImageData", "ImagePath"))
.Append(_mlContext.Transforms.Resize("ImageResized", imageWidth: ImageWidth, imageHeight: ImageHeight, inputColumnName: "ImageData"))
.Append(_mlContext.Transforms.ExtractPixels(new ColumnInfo("input", "ImageResized", colors: ColorBits.Rgb, interleave: true, asFloat: true, offset: 128f, scale: 1 / 255f)))
.Append(new TensorFlowEstimator(_mlContext, new string[] { @"MobilenetV2/Predictions/Reshape_1" }, new string[] { "input" }, _modelFilePath))
.Append(new CustomMappingEstimator <MovileNetTensorflowPrediction, ImagePrediction>(_mlContext, contractName: "MobileNetExtractor",
mapAction: (networkResult, prediction) =>
{
prediction.Estimate = networkResult.Output.Max();
prediction.Index = networkResult.Output.ToList().IndexOf(prediction.Estimate) - 1; //-1 because result contains 1001
prediction.Label = _labels[prediction.Index];
}));
var transformer = pipeline.Fit(data);
return(transformer.CreatePredictionEngine <ImageData, ImagePrediction> (_mlContext));
}
public void TestEstimatorSaveLoad()
{
IHostEnvironment env = new MLContext();
var dataFile = GetDataPath("images/images.tsv");
var imageFolder = Path.GetDirectoryName(dataFile);
var data = TextLoader.Create(env, new TextLoader.Arguments()
{
Column = new[]
{
new TextLoader.Column("ImagePath", DataKind.TX, 0),
new TextLoader.Column("Name", DataKind.TX, 1),
}
}, new MultiFileSource(dataFile));
var pipe = new ImageLoadingEstimator(env, imageFolder, ("ImagePath", "ImageReal"))
.Append(new ImageResizingEstimator(env, "ImageReal", "ImageReal", 100, 100))
.Append(new ImagePixelExtractingEstimator(env, "ImageReal", "ImagePixels"))
.Append(new ImageGrayscalingEstimator(env, ("ImageReal", "ImageGray")));
pipe.GetOutputSchema(Core.Data.SchemaShape.Create(data.Schema));
var model = pipe.Fit(data);
var tempPath = Path.GetTempFileName();
using (var file = new SimpleFileHandle(env, tempPath, true, true))
{
using (var fs = file.CreateWriteStream())
model.SaveTo(env, fs);
var model2 = TransformerChain.LoadFrom(env, file.OpenReadStream());
var newCols = ((ImageLoaderTransform)model2.First()).Columns;
var oldCols = ((ImageLoaderTransform)model.First()).Columns;
Assert.True(newCols
.Zip(oldCols, (x, y) => x == y)
.All(x => x));
}
Done();
}
static void Main(string[] args)
{
Console.Write("Image directory: ");
var imagePath = Console.ReadLine();
var context = new MLContext();
// this is necessary for calling Fit() later
var fakeData = context.Data.ReadFromEnumerable(new List <InputModel>());
// loads images from disk
var imageLoadingEstimator = new ImageLoadingEstimator(
context,
imagePath,
("ImageData", nameof(InputModel.Path)));
// resizes images to required size
var imageResizingEstimator = new ImageResizingEstimator(
context,
"ImageResized",
64,
64,
"ImageData",
ImageResizerTransformer.ResizingKind.IsoPad);
// transforms images to float vectors
var imagePixelExtractingEstimator = new ImagePixelExtractingEstimator(context,
new ImagePixelExtractorTransformer.ColumnInfo(
"input_1",
"ImageResized",
ImagePixelExtractorTransformer.ColorBits.Rgb, interleave: true,
scale: 1 / 255f));
// loads the TF model from disk
var tensorFlowEstimator = new TensorFlowEstimator(
context,
new[] { "final_layer/Sigmoid" },
new[] { "input_1" },
"Model/MalariaModel.pb");
// create a ML pipeline
var pipeline = imageLoadingEstimator
.Append(imageResizingEstimator)
.Append(imagePixelExtractingEstimator)
.Append(tensorFlowEstimator);
// fit, otherwise we can't create a prediction engine
var model = pipeline.Fit(fakeData);
var predictor = model.CreatePredictionEngine <InputModel, OutputModel>(context);
foreach (var file in Directory.GetFiles(imagePath, "*.png").Take(100).ToList())
{
var newName = ImageUtilities.ResizeImage(file, 64, 64, imagePath);
var prediction = predictor.Predict(new InputModel {
Path = newName
});
Console.WriteLine($"{Path.GetFileName(file)}: {(prediction.IsInfected() ? "Infected" : "Healthy")}");
}
Console.ReadLine();
}