dotnet add package Microsoft.ML
dotnet add package Microsoft.ML.AutoML
dotnet add package Microsoft.ML.Vision
dotnet add package Microsoft.ML.ImageAnalytics

dotnet new console -n MLNetDemo
cd MLNetDemo
dotnet add package Microsoft.ML
dotnet restore

using Microsoft.ML.Data;

public class SentimentData
{
    [LoadColumn(0)]
    public string SentimentText { get; set; }
    
    [LoadColumn(1), ColumnName("Label")]
    public bool Sentiment { get; set; }
}

public class SentimentPrediction
{
    [ColumnName("PredictedLabel")]
    public bool Prediction { get; set; }
    
    public float Probability { get; set; }
    
    public float Score { get; set; }
}

using Microsoft.ML;
using System;
using System.IO;

class Program
{
    static void Main(string[] args)
    {
        // MLContext 생성 (시드 값으로 재현 가능한 결과 보장)
        var mlContext = new MLContext(seed: 0);
        
        // 데이터 로드
        string dataPath = "sentiment_data.csv";
        IDataView dataView = mlContext.Data.LoadFromTextFile<sentimentdata>(
            dataPath, 
            hasHeader: true, 
            separatorChar: ','
        );
        
        // 학습/테스트 데이터 분리 (80% 학습, 20% 테스트)
        var splitData = mlContext.Data.TrainTestSplit(
            dataView, 
            testFraction: 0.2
        );
        
        Console.WriteLine("데이터 로드 완료! 🎉");
    }
}</sentimentdata>

// 데이터 변환 파이프라인 정의
var dataProcessPipeline = mlContext.Transforms.Text
    .FeaturizeText(
        outputColumnName: "Features", 
        inputColumnName: nameof(SentimentData.SentimentText)
    );

Console.WriteLine("텍스트를 숫자 특성으로 변환하는 파이프라인 생성 완료! 🔄");

// 학습 알고리즘 추가 (SdcaLogisticRegression 사용)
var trainer = mlContext.BinaryClassification.Trainers
    .SdcaLogisticRegression(
        labelColumnName: "Label", 
        featureColumnName: "Features"
    );

// 전체 파이프라인 구성
var trainingPipeline = dataProcessPipeline.Append(trainer);

Console.WriteLine("학습 파이프라인 구성 완료! 🏗️");

// 모델 학습
Console.WriteLine("모델 학습 시작... ⏳");
var trainedModel = trainingPipeline.Fit(splitData.TrainSet);
Console.WriteLine("모델 학습 완료! 🎓");

// 모델 저장
string modelPath = "sentiment_model.zip";
mlContext.Model.Save(trainedModel, splitData.TrainSet.Schema, modelPath);
Console.WriteLine($"모델이 {modelPath}에 저장되었습니다! 💾");

// 테스트 데이터로 예측 수행
var predictions = trainedModel.Transform(splitData.TestSet);

// 모델 평가
var metrics = mlContext.BinaryClassification.Evaluate(
    predictions, 
    labelColumnName: "Label"
);

// 평가 결과 출력
Console.WriteLine("=== 모델 평가 결과 ===");
Console.WriteLine($"정확도 (Accuracy): {metrics.Accuracy:P2}");
Console.WriteLine($"AUC: {metrics.AreaUnderRocCurve:P2}");
Console.WriteLine($"F1 Score: {metrics.F1Score:P2}");
Console.WriteLine($"정밀도 (Precision): {metrics.PositivePrecision:P2}");
Console.WriteLine($"재현율 (Recall): {metrics.PositiveRecall:P2}");

// 예측 엔진 생성
var predictionEngine = mlContext.Model
    .CreatePredictionEngine<sentimentdata, sentimentprediction="">(trainedModel);

// 테스트할 샘플 데이터
var sampleData = new SentimentData[]
{
    new SentimentData { SentimentText = "이 제품 정말 최고예요! 강력 추천합니다." },
    new SentimentData { SentimentText = "완전 실망이에요. 돈 아깝습니다." },
    new SentimentData { SentimentText = "그냥 그래요. 보통입니다." }
};

Console.WriteLine("\n=== 감정 분석 결과 ===");
foreach (var sample in sampleData)
{
    var prediction = predictionEngine.Predict(sample);
    
    Console.WriteLine($"\n텍스트: {sample.SentimentText}");
    Console.WriteLine($"예측: {(prediction.Prediction ? "😊 긍정" : "😞 부정")}");
    Console.WriteLine($"확률: {prediction.Probability:P2}");
    Console.WriteLine($"신뢰도 점수: {prediction.Score:F4}");
}</sentimentdata,>

using Microsoft.ML.AutoML;

// AutoML 실험 설정
var experimentSettings = new BinaryExperimentSettings
{
    MaxExperimentTimeInSeconds = 60,  // 1분 동안 실험
    OptimizingMetric = BinaryClassificationMetric.Accuracy
};

// AutoML 실험 실행
Console.WriteLine("AutoML 실험 시작... 🔬");
var experiment = mlContext.Auto()
    .CreateBinaryClassificationExperiment(experimentSettings);

var experimentResult = experiment.Execute(
    trainData: splitData.TrainSet,
    validationData: splitData.TestSet,
    labelColumnName: "Label"
);

// 최고 성능 모델 정보 출력
Console.WriteLine($"\n최고 성능 알고리즘: {experimentResult.BestRun.TrainerName}");
Console.WriteLine($"정확도: {experimentResult.BestRun.ValidationMetrics.Accuracy:P2}");

// 최고 성능 모델 사용
var bestModel = experimentResult.BestRun.Model;

MLNetProject/
├── Data/
│   ├── Models/              # 데이터 모델 클래스
│   │   ├── SentimentData.cs
│   │   └── SentimentPrediction.cs
│   └── Datasets/            # 학습 데이터
│       └── sentiment_data.csv
├── Services/
│   ├── IMLService.cs        # 인터페이스
│   ├── SentimentAnalysisService.cs
│   └── ModelTrainingService.cs
├── Models/                  # 저장된 ML 모델
│   └── sentiment_model.zip
├── Utils/
│   ├── DataLoader.cs
│   └── ModelEvaluator.cs
└── Program.cs

public interface IMLService
{
    SentimentPrediction PredictSentiment(string text);
    Task<sentimentprediction> PredictSentimentAsync(string text);
}

public class SentimentAnalysisService : IMLService
{
    private readonly MLContext _mlContext;
    private readonly ITransformer _model;
    private readonly PredictionEngine<sentimentdata, sentimentprediction=""> _predictionEngine;

    public SentimentAnalysisService(string modelPath)
    {
        _mlContext = new MLContext();
        
        // 저장된 모델 로드
        _model = _mlContext.Model.Load(modelPath, out var modelSchema);
        
        // 예측 엔진 생성
        _predictionEngine = _mlContext.Model
            .CreatePredictionEngine<sentimentdata, sentimentprediction="">(_model);
    }

    public SentimentPrediction PredictSentiment(string text)
    {
        var input = new SentimentData { SentimentText = text };
        return _predictionEngine.Predict(input);
    }

    public Task<sentimentprediction> PredictSentimentAsync(string text)
    {
        // 비동기 래퍼 (실제 예측은 동기)
        return Task.Run(() => PredictSentiment(text));
    }
}</sentimentprediction></sentimentdata,></sentimentdata,></sentimentprediction>

// Startup.cs 또는 Program.cs
public void ConfigureServices(IServiceCollection services)
{
    services.AddControllers();
    
    // ML 서비스 등록 (싱글톤으로)
    services.AddSingleton<imlservice>(sp => 
        new SentimentAnalysisService("Models/sentiment_model.zip")
    );
}

// API Controller
[ApiController]
[Route("api/[controller]")]
public class SentimentController : ControllerBase
{
    private readonly IMLService _mlService;

    public SentimentController(IMLService mlService)
    {
        _mlService = mlService;
    }

    [HttpPost("analyze")]
    public ActionResult<sentimentresult> AnalyzeSentiment([FromBody] TextInput input)
    {
        try
        {
            var prediction = _mlService.PredictSentiment(input.Text);
            
            return Ok(new SentimentResult
            {
                Text = input.Text,
                IsPositive = prediction.Prediction,
                Confidence = prediction.Probability,
                Score = prediction.Score
            });
        }
        catch (Exception ex)
        {
            return BadRequest(new { error = ex.Message });
        }
    }
}

public class TextInput
{
    public string Text { get; set; }
}

public class SentimentResult
{
    public string Text { get; set; }
    public bool IsPositive { get; set; }
    public float Confidence { get; set; }
    public float Score { get; set; }
}</sentimentresult></imlservice>

public class HouseData
{
    [LoadColumn(0)]
    public float Size { get; set; }
    
    [LoadColumn(1)]
    public float Bedrooms { get; set; }
    
    [LoadColumn(2)]
    public float Age { get; set; }
    
    [LoadColumn(3)]
    public float Price { get; set; }
}

public class HousePricePrediction
{
    [ColumnName("Score")]
    public float PredictedPrice { get; set; }
}

// 회귀 모델 학습
var pipeline = mlContext.Transforms
    .Concatenate("Features", "Size", "Bedrooms", "Age")
    .Append(mlContext.Regression.Trainers.FastTree(
        labelColumnName: "Price",
        featureColumnName: "Features"
    ));

var model = pipeline.Fit(trainingData);

using Microsoft.ML.Vision;

public class ImageData
{
    [LoadColumn(0)]
    public string ImagePath { get; set; }
    
    [LoadColumn(1)]
    public string Label { get; set; }
}

// 이미지 분류 파이프라인
var pipeline = mlContext.Transforms
    .LoadImages("Image", null, nameof(ImageData.ImagePath))
    .Append(mlContext.Transforms.ResizeImages(
        "Image", 224, 224, "Image"))
    .Append(mlContext.Transforms.ExtractPixels("Image"))
    .Append(mlContext.MulticlassClassification.Trainers
        .ImageClassification(
            featureColumnName: "Image",
            labelColumnName: "Label"
        ));

var model = pipeline.Fit(imageData);

public class ProductEntry
{
    [LoadColumn(0)]
    public float UserId { get; set; }
    
    [LoadColumn(1)]
    public float ProductId { get; set; }
    
    [LoadColumn(2)]
    public float Rating { get; set; }
}

public class ProductPrediction
{
    public float Score { get; set; }
}

// 행렬 분해 기반 추천 시스템
var pipeline = mlContext.Recommendation().Trainers
    .MatrixFactorization(
        labelColumnName: "Rating",
        matrixColumnIndexColumnName: "UserId",
        matrixRowIndexColumnName: "ProductId",
        numberOfIterations: 20,
        approximationRank: 100
    );

var model = pipeline.Fit(trainingData);

public class TransactionData
{
    [LoadColumn(0)]
    public float Amount { get; set; }
    
    [LoadColumn(1)]
    public float Time { get; set; }
    
    [LoadColumn(2)]
    public float Location { get; set; }
}

public class AnomalyPrediction
{
    [ColumnName("PredictedLabel")]
    public bool IsAnomaly { get; set; }
    
    [ColumnName("Score")]
    public float Score { get; set; }
}

// 이상 탐지 모델
var pipeline = mlContext.Transforms
    .Concatenate("Features", "Amount", "Time", "Location")
    .Append(mlContext.AnomalyDetection.Trainers
        .RandomizedPca(
            featureColumnName: "Features",
            rank: 3,
            ensureZeroMean: true
        ));

var model = pipeline.Fit(trainingData);

public class ModelCache
{
    private static readonly Lazy<itransformer> _lazyModel = 
        new Lazy<itransformer>(() => LoadModel());
    
    private static ITransformer LoadModel()
    {
        var mlContext = new MLContext();
        return mlContext.Model.Load("model.zip", out _);
    }
    
    public static ITransformer Model => _lazyModel.Value;
}</itransformer></itransformer>

// 느린 방법 (하나씩)
foreach (var item in items)
{
    var prediction = predictionEngine.Predict(item);
}

// 빠른 방법 (배치)
var dataView = mlContext.Data.LoadFromEnumerable(items);
var predictions = model.Transform(dataView);
var results = mlContext.Data
    .CreateEnumerable<sentimentprediction>(predictions, reuseRowObject: false)
    .ToList();</sentimentprediction>

// 특성 중요도 확인
var permutationMetrics = mlContext.BinaryClassification
    .PermutationFeatureImportance(
        model, 
        testData, 
        labelColumnName: "Label"
    );

// 중요한 특성만 선택
var importantFeatures = permutationMetrics
    .Select((metric, index) => new { Index = index, Importance = metric.AreaUnderRocCurve.Mean })
    .OrderByDescending(x => x.Importance)
    .Take(10)
    .Select(x => x.Index)
    .ToList();

public void ValidateData(IDataView data)
{
    var preview = data.Preview(maxRows: 10);
    
    Console.WriteLine("=== 데이터 미리보기 ===");
    foreach (var row in preview.RowView)
    {
        foreach (var column in row.Values)
        {
            Console.Write($"{column.Key}: {column.Value} | ");
        }
        Console.WriteLine();
    }
    
    // 결측치 확인
    var schema = data.Schema;
    foreach (var column in schema)
    {
        Console.WriteLine($"컬럼: {column.Name}, 타입: {column.Type}");
    }
}

// 5-Fold 교차 검증
var cvResults = mlContext.BinaryClassification.CrossValidate(
    data: trainingData,
    estimator: pipeline,
    numberOfFolds: 5,
    labelColumnName: "Label"
);

// 평균 성능 계산
var avgAccuracy = cvResults.Average(r => r.Metrics.Accuracy);
var avgAuc = cvResults.Average(r => r.Metrics.AreaUnderRocCurve);

Console.WriteLine($"평균 정확도: {avgAccuracy:P2}");
Console.WriteLine($"평균 AUC: {avgAuc:P2}");

// 표준편차로 안정성 확인
var stdAccuracy = Math.Sqrt(
    cvResults.Average(r => Math.Pow(r.Metrics.Accuracy - avgAccuracy, 2))
);
Console.WriteLine($"정확도 표준편차: {stdAccuracy:P2}");

public class IntentData
{
    public string Text { get; set; }
    public string Intent { get; set; }  // "질문", "불만", "칭찬", "요청" 등
}

// 다중 클래스 분류
var pipeline = mlContext.Transforms.Text
    .FeaturizeText("Features", nameof(IntentData.Text))
    .Append(mlContext.MulticlassClassification.Trainers
        .SdcaMaximumEntropy("Intent", "Features"));

public class UserBehavior
{
    public float UserId { get; set; }
    public float TalentId { get; set; }
    public float ViewTime { get; set; }
    public float Rating { get; set; }
    public bool Purchased { get; set; }
}

// 복합 추천 시스템
var pipeline = mlContext.Transforms
    .Concatenate("Features", "ViewTime", "Rating")
    .Append(mlContext.Recommendation().Trainers
        .MatrixFactorization(
            labelColumnName: nameof(UserBehavior.Purchased),
            matrixColumnIndexColumnName: nameof(UserBehavior.UserId),
            matrixRowIndexColumnName: nameof(UserBehavior.TalentId)
        ));

public class SecureMLService
{
    private readonly ILogger _logger;
    private readonly IDataProtector _protector;
    
    public SecureMLService(
        ILogger<securemlservice> logger,
        IDataProtectionProvider provider)
    {
        _logger = logger;
        _protector = provider.CreateProtector("MLService");
    }
    
    public SentimentPrediction PredictSecure(string encryptedText)
    {
        // 복호화
        var text = _protector.Unprotect(encryptedText);
        
        // 예측
        var prediction = _predictionEngine.Predict(
            new SentimentData { SentimentText = text }
        );
        
        // 로깅 (민감한 정보 제외)
        _logger.LogInformation(
            "Prediction made: IsPositive={IsPositive}, Confidence={Confidence}",
            prediction.Prediction,
            prediction.Probability
        );
        
        return prediction;
    }
}</securemlservice>