Data Science и C#

public class Customer
{
    public string Id { get; }
    public string Name { get; }
    public int Age { get; }
    public string Country { get; }
    public double AnnualSpending { get; }
 
    public Customer(string id, string name, int age, string country, double annualSpending)
    {
        Id = id;
        Name = name;
        Age = age;
        Country = country;
        AnnualSpending = annualSpending;
    }
}

public record Customer(string Id, string Name, int Age, string Country, double AnnualSpending);

var customers = [
    new Customer("C001", "Алексей", 30, "Россия", 25000),
    new Customer("C002", "Борис", 22, "Беларусь", 15000),
    new Customer("C003", "Виктория", 40, "Казахстан", 32000),
    new Customer("C004", "Дарья", 35, "Россия", 28000),
];

foreach (var c in customers)
{
    var segment = c switch
    {
        { AnnualSpending: >= 30000 } => "Премиум",
        { AnnualSpending: >= 20000 and < 30000 } => "Стандарт",
        { Country: "Россия", Age: < 25 } => "Молодежный",
        _ => "Базовый"
    };
    Console.WriteLine($"{c.Name} в сегменте {segment}.");
}

await Parallel.ForEachAsync(customers, async (customer, token) =>
{
    var enrichedData = await EnrichCustomerDataAsync(customer);
    await ProcessEnrichedDataAsync(enrichedData);
});

public static double CalculateAverage(ReadOnlySpan<double> values)
{
    double sum = 0;
    for (int i = 0; i < values.Length; i++)
    {
        sum += values[i];
    }
    return sum / values.Length;
}

var query = context.Customers
    .Where(c => c.Country == "Россия")
    .Where(c => c.AnnualSpending > threshold) // threshold - параметр, меняющийся в рантайме
    .GroupBy(c => c.Age / 10 * 10)
    .Select(g => new { AgeGroup = g.Key, AvgSpending = g.Average(c => c.AnnualSpending) });

[DataProcessor]
public partial class TransactionAnalyzer
{
    [ProcessingStep]
    public decimal CalculateRisk(Transaction tx) => tx.Amount * RiskFactor(tx.Category);
}

public static void MatrixMultiply(
    Index2D index,
    ArrayView2D<float, Stride2D.DenseX> a,
    ArrayView2D<float, Stride2D.DenseX> b,
    ArrayView2D<float, Stride2D.DenseX> c)
{
    var x = index.X;
    var y = index.Y;
    float sum = 0.0f;
    for (int i = 0; i < a.IntExtent.X; ++i)
        sum += a[y, i] * b[i, x];
    c[y, x] = sum;
}

using Apache.Arrow;
using Apache.Arrow.Ipc;
 
using var arrowStream = new FileStream("data.arrow", FileMode.Open);
using var reader = new ArrowStreamReader(arrowStream);
RecordBatch batch;
 
while ((batch = reader.ReadNextRecordBatch()) != null)
{
    var nameColumn = batch.Column("Name") as StringArray;
    var ageColumn = batch.Column("Age") as Int32Array;
    
    for (int i = 0; i < batch.Length; i++)
    {
        Console.WriteLine($"{nameColumn.GetString(i)}, {ageColumn.GetValue(i)}");
    }
}

var stockPrices = new TimeSeriesData<decimal>(
    timestamps: [DateTime.Parse("2023-01-01"), DateTime.Parse("2023-01-02"), DateTime.Parse("2023-01-03")],
    values: [125.30m, 127.80m, 124.50m]
);
 
var movingAverage = stockPrices.Window(3).Select(window => window.Average());
var volatility = stockPrices.CalculateVolatility(WindowSize: 5);

public unsafe static void FastMatrixMultiply(double[] a, double[] b, double[] result, int n)
{
    fixed (double* pA = a, pB = b, pRes = result)
    {
        for (int i = 0; i < n; i++)
        {
            for (int j = 0; j < n; j++)
            {
                double sum = 0;
                for (int k = 0; k < n; k++)
                {
                    sum += pA[i * n + k] * pB[k * n + j];
                }
                pRes[i * n + j] = sum;
            }
        }
    }
}

[Union]
public abstract record DataSource
{
    public sealed record DatabaseSource(string ConnectionString, string Query) : DataSource;
    public sealed record FileSource(string Path, string Format) : DataSource;
    public sealed record ApiSource(Uri Endpoint, string AuthToken) : DataSource;
}
 
public DataResult ProcessData(DataSource source) => source switch
{
    DataSource.DatabaseSource db => FetchFromDatabase(db.ConnectionString, db.Query),
    DataSource.FileSource file => ParseFile(file.Path, file.Format),
    DataSource.ApiSource api => CallApi(api.Endpoint, api.AuthToken),
    _ => throw new ArgumentException("Unknown data source type")
};

// Раньше
Func<Customer, bool> isPremium = c => c.AnnualSpending > 30000;
 
// Теперь
var isPremium = (Customer c) => c.AnnualSpending > 30000;
 
// Использование в конвейере обработки
var premiumCustomers = customers
    .Where(isPremium)
    .Select(c => new { c.Name, Status = "Premium" });

public readonly ref struct DataPoint
{
    public readonly double X { get; }
    public readonly double Y { get; }
    
    public DataPoint(double x, double y)
    {
        X = x;
        Y = y;
    }
    
    public readonly double Distance => Math.Sqrt(X * X + Y * Y);
}
 
public static void ProcessDataPoints(ReadOnlySpan<DataPoint> points)
{
    for (int i = 0; i < points.Length; i++)
    {
        if (points[i].Distance > 5.0)
        {
            // Обработка точек...
        }
    }
}

// Новые удобные методы для статистического анализа
var stats = customers
    .GroupBy(c => c.Country)
    .Select(g => new
    {
        Country = g.Key,
        AverageSpending = g.Average(c => c.AnnualSpending),
        MedianSpending = g.Median(c => c.AnnualSpending),
        SpendingStdDev = g.StdDev(c => c.AnnualSpending),
        CustomerCount = g.Count(),
        Top5Customers = g.OrderByDescending(c => c.AnnualSpending).Take(5).ToList()
    });

public async Task<List<AnomalyAlert>> DetectAnomaliesAsync(Stream transactionStream)
{
    using var arrowReader = new ArrowStreamReader(transactionStream);
    var batches = new List<RecordBatch>();
    RecordBatch batch;
    
    // Загрузка данных из Arrow-формата
    while ((batch = await arrowReader.ReadNextRecordBatchAsync()) != null)
        batches.Add(batch);
    
    // Преобразование в TimeSeriesData
    var timeSeriesData = ConvertToTimeSeries(batches);
    
    // Параллельный анализ аномалий
    var alerts = new ConcurrentBag<AnomalyAlert>();
    
    await Parallel.ForEachAsync(timeSeriesData.Accounts, async (accountData, token) =>
    {
        var anomalies = await accountData switch
        {
            { TransactionCount: > 100 } => RunDeepAnomalyDetection(accountData),
            { AvgAmount: > 10000 } => RunHighValueAnalysis(accountData),
            _ => RunStandardAnalysis(accountData)
        };
        
        foreach (var anomaly in anomalies)
            alerts.Add(new AnomalyAlert(accountData.AccountId, anomaly));
    });
    
    return alerts.ToList();
}

var mlContext = new MLContext(seed: 0);
 
// Загрузка данных
var dataView = mlContext.Data.LoadFromTextFile<SentimentData>("sentiment.txt", 
                                                             hasHeader: true);
 
// Определение пайплайна
var pipeline = mlContext.Transforms.Text.FeaturizeText("Features", "Text")
    .Append(mlContext.BinaryClassification.Trainers.SdcaLogisticRegression());
 
// Обучение модели
var model = pipeline.Fit(dataView);
 
// Предсказание
var predictor = mlContext.Model.CreatePredictionEngine<SentimentData, SentimentPrediction>(model);
var prediction = predictor.Predict(new SentimentData { Text = "Этот продукт просто отличный!" });
Console.WriteLine($"Sentiment: {(prediction.Prediction ? "Позитивный" : "Негативный")}");

// Работа с матрицами через Math.NET
var matrixA = Matrix<double>.Build.Random(1000, 1000);
var matrixB = Matrix<double>.Build.Random(1000, 1000);
var result = matrixA.Multiply(matrixB);
 
// Аналог NumPy через NumSharp
var ndA = np.random.rand(1000, 1000);
var ndB = np.random.rand(1000, 1000);
var ndResult = np.dot(ndA, ndB);

// Создание графика через Plotly.NET
var chart = Chart.Line(
    x: dateRange,
    y: stockPrices,
    Name: "SBER"
);
chart.WithTitle("Динамика акций Сбербанка")
     .WithXAxisStyle(Title.init("Дата"))
     .WithYAxisStyle(Title.init("Цена"))
     .Show();

// Загрузка данных в DataFrame
var df = Frame.ReadCsv("transactions.csv");
 
// Группировка и агрегация
var result = df
    .GroupBy("Region")
    .Aggregate(
        new SeriesBuilder<string, double>()
            .Add("TotalSales", s => s.GetAs<double>("Amount").Sum())
            .Add("AverageSales", s => s.GetAs<double>("Amount").Mean())
            .Add("Transactions", s => s.RowCount)
            .Result
    );

using var session = new InferenceSession("model.onnx");
 
// Подготовка входных данных
var inputMeta = session.InputMetadata;
var inputName = inputMeta.Keys.First();
var tensor = new DenseTensor<float>(new[] { 1, 784 });
 
// Запуск инференса
var inputs = new List<NamedOnnxValue> { NamedOnnxValue.CreateFromTensor(inputName, tensor) };
using var results = session.Run(inputs);
var output = results.First().AsEnumerable<float>().ToArray();

// Инициализация среды Python
Runtime.PythonDLL = @"C:\Python38\python38.dll";
PythonEngine.Initialize();
 
// Использование pandas через Python.NET
dynamic pd = Py.Import("pandas");
dynamic np = Py.Import("numpy");
 
dynamic df = pd.DataFrame(new Dictionary<string, object> {
    { "A", np.random.rand(100) },
    { "B", np.random.rand(100) }
});
 
// Вызов методов pandas
dynamic correlation = df.corr();
Console.WriteLine($"Correlation: {correlation["A"]["B"]}");

// Создание SparkSession
var spark = SparkSession.Builder()
    .AppName("CSharpSparkExample")
    .GetOrCreate();
 
// Загрузка и обработка данных
var dataFrame = spark.Read().Option("header", "true").Csv("data.csv");
var result = dataFrame
    .Filter("Amount > 1000")
    .GroupBy("CustomerID")
    .Agg(Functions.Sum("Amount"), Functions.Count("TransactionID"));

[Benchmark]
public double ClassicKMeans()
{
    // Реализация алгоритма
}
 
[Benchmark]
public double OptimizedKMeans()
{
    // Оптимизированная версия
}

// Запрос к TimescaleDB с использованием Npgsql
using var conn = new NpgsqlConnection(connString);
conn.Open();
using var cmd = new NpgsqlCommand(@"
    SELECT time_bucket('1 day', time) AS day,
           avg(temperature)
    FROM sensor_data
    WHERE location = @location
    GROUP BY day
    ORDER BY day DESC
    LIMIT 30", conn);
cmd.Parameters.AddWithValue("location", "server-room");

using var db = new DuckDBConnection("DataSource=:memory:");
db.Open();
 
// Загрузка данных из CSV
using var cmd = db.CreateCommand();
cmd.CommandText = "CREATE TABLE sales AS SELECT * FROM read_csv_auto('sales.csv')";
cmd.ExecuteNonQuery();
 
// Аналитический запрос
cmd.CommandText = @"
    SELECT region, product_category, 
           SUM(amount) as total_sales,
           AVG(amount) as avg_sale
    FROM sales
    GROUP BY region, product_category
    ORDER BY total_sales DESC";

services.AddMassTransit(x => {
    x.UsingRabbitMq((context, cfg) => {
        cfg.Host("rabbitmq://localhost");
        
        cfg.ReceiveEndpoint("data-processing", e => {
            e.Consumer<TransactionDataConsumer>(context);
        });
    });
});

var client = new ElasticClient(new Uri("http://localhost:9200"));
 
// Индексация документов
var indexResponse = client.IndexDocument(new CustomerFeedback
{
    Id = "FB1001",
    Text = "Приложение работает стабильно, но интерфейс неудобный",
    Rating = 3,
    ProductCategory = "Mobile App",
    Timestamp = DateTime.Now
});
 
// Полнотекстовый поиск с аналитической агрегацией
var searchResponse = client.Search<CustomerFeedback>(s => s
    .Query(q => q
        .Match(m => m
            .Field(f => f.Text)
            .Query("интерфейс неудобный")
        )
    )
    .Aggregations(a => a
        .Average("avg_rating", avg => avg.Field(f => f.Rating))
        .Terms("by_category", t => t.Field(f => f.ProductCategory))
    )
);

#r "nuget:Microsoft.Data.Analysis"
#r "nuget:XPlot.Plotly"
 
using Microsoft.Data.Analysis;
using XPlot.Plotly;
 
// Загрузка и анализ данных в интерактивном режиме
var df = DataFrame.LoadCsv("customer_data.csv");
display(df.Head(10));
 
// Интерактивная визуализация
var chart = Chart.Plot(
    new Graph.Scatter()
    {
        x = df["Age"].Cast<int>().ToArray(),
        y = df["Income"].Cast<double>().ToArray(),
        mode = "markers"
    }
);
display(chart);

// Статистический анализ
double[] sample = { 4.5, 5.1, 5.5, 5.8, 6.2, 6.5, 6.8, 7.1, 7.4 };
var stats = new DescriptiveAnalysis(sample);
 
Console.WriteLine($"Mean: {stats.Mean}");
Console.WriteLine($"Standard Deviation: {stats.StandardDeviation}");
 
// Машинное обучение
var kmeans = new KMeans(k: 3);
var clusters = kmeans.Learn(observations);
 
// Обработка сигналов
var filter = new MovingAverage(5);
double[] filtered = filter.Apply(signal);

// Подключение к Azure ML
var workspace = Workspace.Get(
    subscriptionId: "<subscription-id>",
    resourceGroupName: "<resource-group>",
    workspaceName: "<workspace-name>"
);
 
// Регистрация модели ML.NET в Azure
var model = mlContext.Model.Load("model.zip", out _);
Model.Register(workspace, "banking_classifier", "models/model.zip");
 
// Развертывание сервиса для инференса
var webService = Model.Deploy(workspace,
    "banking-classifier-service",
    new[] { RegisteredModel(workspace, "banking_classifier") },
    InferenceConfig("score.py", runtimeEnvironment),
    DeploymentConfig()
);

var tracerProvider = Sdk.CreateTracerProviderBuilder()
    .AddSource("ML.Prediction")
    .SetResourceBuilder(ResourceBuilder.CreateDefault().AddService("FraudDetection"))
    .AddConsoleExporter()
    .AddOtlpExporter()
    .Build();
 
// Трассировка ML-операций
var tracer = tracerProvider.GetTracer("ML.Prediction");
using var span = tracer.StartActiveSpan("ModelPrediction");
span.SetAttribute("model.version", "1.2.3");
span.SetAttribute("input.size", inputData.Length);
 
var prediction = predictor.Predict(inputData);
 
span.SetAttribute("prediction.result", prediction.Label);
span.SetAttribute("prediction.confidence", prediction.Score);