using Microsoft.ML;
using Microsoft.ML.Data;

private readonly string _inceptionTensorFlowModel; // путь к модели Inception
    private MLContext mlContext;
    private ITransformer model;
    private DataViewSchema schema;
    private string modelName = "model.zip"; // название модели для её сохранения
    private string _setsPath = @"C:\datasets"; // путь к сетам и место, куда будет сложена модель после сохранения
        public Model(string inceptionTensorFlowModel)
        {
            mlContext = new MLContext();
            _inceptionTensorFlowModel = inceptionTensorFlowModel;
        }

public class ImageData
    {
        [LoadColumn(0)]
        public string ImagePath;
        [LoadColumn(1)]
        public string Label;
      //метод, который я использую, чтобы забрать данные из папок и отмаркировать их
        public static (IEnumerable<ImageData> train, IEnumerable<ImageData> test) ReadData(string pathToFolder)
        {
            List<ImageData> list = new List<ImageData>();
            var directories = Directory.EnumerateDirectories(pathToFolder);
            foreach (var dir in directories)
            {
                if (!dir.Contains("girls") && !dir.Contains("boys") && !dir.Contains("trash") && !dir.Contains("other"))
                    continue;
                var label = dir.Split(@"").Last();
                foreach (var file in Directory.GetFiles(dir))
                {
                    list.Add(new ImageData()
                    {
                        ImagePath = file,
                        Label = label
                    });
                }
            }
            list = list.Shuffle().ToList();
            return GetSets(list);
        }
        //Делим изображения на тестовую и основную выборки
        public static (IEnumerable<ImageData> train, IEnumerable<ImageData> test) GetSets(IEnumerable<ImageData> data)
        {
            var trainCount = data.Count() / 100 * 99;
            var train = data.Take(trainCount);
            var test = data.Skip(trainCount);
            return (train, test);
        }
    }
    public class ImagePrediction : ImageData
    {
        [ColumnName("Score")]
        public float[] Score;
        public string PredictedLabelValue;
    }

public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> source)
        {
            return source.Shuffle(new Random());
        }
        public static IEnumerable<T> Shuffle<T>(this IEnumerable<T> source, Random rng)
        {
            if (source == null) throw new ArgumentNullException("source");
            if (rng == null) throw new ArgumentNullException("rng");
            return source.ShuffleIterator(rng);
        }
        private static IEnumerable<T> ShuffleIterator<T>(
            this IEnumerable<T> source, Random rng)
        {
            var buffer = source.ToList();
            for (int i = 0; i < buffer.Count; i++)
            {
                int j = rng.Next(i, buffer.Count);
                yield return buffer[j];
                buffer[j] = buffer[i];
            }
        }

private struct InceptionSettings
        {
            public const int ImageHeight = 224;
            public const int ImageWidth = 224;
            public const float Mean = 117;
            public const float Scale = 1;
            public const bool ChannelsLast = true;
        }

private double TrainModel()
        {
            IEstimator<ITransformer> pipeline = mlContext.Transforms.LoadImages(outputColumnName: "input", imageFolder: "", inputColumnName: nameof(ImageData.ImagePath))
                           .Append(mlContext.Transforms.ResizeImages(outputColumnName: "input", imageWidth: InceptionSettings.ImageWidth, imageHeight: InceptionSettings.ImageHeight, inputColumnName: "input"))
                           .Append(mlContext.Transforms.ExtractPixels(outputColumnName: "input", interleavePixelColors: InceptionSettings.ChannelsLast, offsetImage: InceptionSettings.Mean))
                           .Append(mlContext.Model.LoadTensorFlowModel(_inceptionTensorFlowModel).
                               ScoreTensorFlowModel(outputColumnNames: new[] { "softmax2_pre_activation" }, inputColumnNames: new[] { "input" }, addBatchDimensionInput: true))
                           .Append(mlContext.Transforms.Conversion.MapValueToKey(outputColumnName: "LabelKey", inputColumnName: "Label"))
                           .Append(mlContext.MulticlassClassification.Trainers.LbfgsMaximumEntropy(labelColumnName: "LabelKey", featureColumnName: "softmax2_pre_activation"))
                           .Append(mlContext.Transforms.Conversion.MapKeyToValue("PredictedLabelValue", "PredictedLabel"))
                           .AppendCacheCheckpoint(mlContext);
            var loadImages = ImageData.ReadData(_setsPath);
            IDataView trainingData = mlContext.Data.LoadFromEnumerable<ImageData>(loadImages.train);
            ITransformer model = pipeline.Fit(trainingData);
            IDataView testData = mlContext.Data.LoadFromEnumerable<ImageData>(loadImages.test);
            IDataView predictions = model.Transform(testData);
            List<ImagePrediction> imagePredictionData = mlContext.Data.CreateEnumerable<ImagePrediction>(predictions, true).ToList();
            MulticlassClassificationMetrics metrics =
                mlContext.MulticlassClassification.Evaluate(predictions,
                  labelColumnName: "LabelKey",
                  predictedLabelColumnName: "PredictedLabel");
            schema = trainingData.Schema;
            return metrics.LogLoss;
        }

IEstimator<ITransformer> pipeline = mlContext.Transforms.LoadImages(outputColumnName: "input", imageFolder: "", inputColumnName: nameof(ImageData.ImagePath))
     .Append(mlContext.Transforms.ResizeImages(outputColumnName: "input", imageWidth: InceptionSettings.ImageWidth, imageHeight: InceptionSettings.ImageHeight, inputColumnName: "input"))
     .Append(mlContext.Transforms.ExtractPixels(outputColumnName: "input", interleavePixelColors: InceptionSettings.ChannelsLast, offsetImage: InceptionSettings.Mean))

.Append(mlContext.Model.LoadTensorFlowModel(_inceptionTensorFlowModel).
    ScoreTensorFlowModel(outputColumnNames: new[] { "softmax2_pre_activation" }, inputColumnNames: new[] { "input" }, addBatchDimensionInput: true))

.Append(mlContext.Transforms.Conversion.MapValueToKey(outputColumnName: "LabelKey", inputColumnName: "Label"))

.Append(mlContext.MulticlassClassification.Trainers.LbfgsMaximumEntropy(labelColumnName: "LabelKey", featureColumnName: "softmax2_pre_activation"))

.Append(mlContext.Transforms.Conversion.MapKeyToValue("PredictedLabelValue", "PredictedLabel"))
.AppendCacheCheckpoint(mlContext);

var loadImages = ImageData.ReadData(_setsPath);
            IDataView trainingData = mlContext.Data.LoadFromEnumerable<ImageData>(loadImages.train);
            model = pipeline.Fit(trainingData);

IDataView testData = mlContext.Data.LoadFromEnumerable<ImageData>(loadImages.test);
            IDataView predictions = model.Transform(testData);
            List<ImagePrediction> imagePredictionData = mlContext.Data.CreateEnumerable<ImagePrediction>(predictions, true).ToList();
            MulticlassClassificationMetrics metrics =
                mlContext.MulticlassClassification.Evaluate(predictions,
                  labelColumnName: "LabelKey",
                  predictedLabelColumnName: "PredictedLabel");

schema = trainingData.Schema;
            return metrics.LogLoss;

public void SaveModel() => mlContext.Model.Save(model, schema, Path.Combine(_setsPath, modelName));

public void FitModel()
    {
        var LogLoss = TrainModel();
        Console.WriteLine($"LogLoss is {LogLoss}");
        SaveModel();
    }

private PredictionEngine<ImageData, ImagePrediction> predictor;

public ImagePrediction ClassifySingleImage(string filePath)
        {
            if (model == null)
                LoadModel();
            if (predictor == null)
                predictor = mlContext.Model.CreatePredictionEngine<ImageData, ImagePrediction>(model);
            var imageData = new ImageData()
            {
                ImagePath = filePath
            };
            return predictor.Predict(imageData);
        }
        public void LoadModel() =>
            model = mlContext.Model.Load(Path.Combine(_setsPath, modelName), out schema);

static void Main(string[] args)
        {
            Console.ForegroundColor = ConsoleColor.White;
            Stopwatch s = new Stopwatch();
            s.Start();
            Model model = new Model(@"C:\tensorflow_inception_graph.pb");
            model.FitModel();
            Console.WriteLine($"##### Model train ended for {s.Elapsed.Minutes}:{s.Elapsed.Seconds} #####");
            s.Restart();
            var res1 = model.ClassifySingleImage(@"C:\EugRqKFXUAYMTWz.jpg");
            Console.WriteLine($" > It's trash. Classification result is {res1.PredictedLabelValue} with score: {res1.Score.Max()}");
            Console.WriteLine($"##### Ended for {s.Elapsed.Minutes}:{s.Elapsed.Seconds} #####");
            s.Restart();
            var res2 = model.ClassifySingleImage(@"C:\EvpmOjIXcAMgj5r.jpg");
            Console.WriteLine($" > It's girl. Classification result is {res2.PredictedLabelValue} with score: {res1.Score.Max()}");
            Console.WriteLine($"##### Ended for {s.Elapsed.Minutes}:{s.Elapsed.Seconds} #####");
        }