Rustic Data: визуализация данных с помощью плоттеров — Часть 1

Если вам кажется заманчивым поднять свои навыки визуализации еще на одну ступень, то не ищите ничего, кроме этой статьи! Четкие пояснения в сочетании с полезными графиками упрощают выполнение, а пошаговые инструкции гарантируют быстрый прогресс в создании захватывающих визуальных эффектов с помощью ящика Плоттеры.

Что такое Плоттеры?

Плоттеры — это надежный и адаптируемый пакет Rust, который позволяет разработчикам, таким как вы, с легкостью создавать потрясающие визуализации. Его универсальность позволяет создавать различные графики, в том числе линейные, точечные и гистограммы, предлагая при этом высокую гибкость вариантов стиля и настраиваемых аннотаций.

Этот инструмент все-в-одном позволяет разработчикам определять любой необходимый тип визуализации, что делает его незаменимым инструментом для задач анализа данных. Одной из примечательных особенностей является поддержка интерактивных интерфейсов, что позволяет легко создавать статическую графику, а также создавать веб-приложения. Эта возможность облегчает изучение наборов данных, что приводит к различным типам графиков, подходящим для машинного обучения или проектов по науке о данных.

Кроме того, плоттеры легко интегрируются в популярные среды разработки, такие как Jupyter Notebook, поддерживая при этом расширенные пакеты, предназначенные исключительно для расширения возможностей визуализации данных, что дает больше причин, по которым этот пакет должен быть частью инструментария каждого разработчика!

Если вы только начинаете свой путь или уже анализируете сложные наборы данных, плоттеры предлагают непревзойденную адаптируемость в сочетании с удобством для пользователя; действительно заслуживает признания среди инструментов высшего уровня, доступных сегодня!

Преимущества плоттеров

Визуализация данных является важнейшим аспектом анализа данных, и библиотека Plotters предоставляет ряд преимуществ, упрощающих этот процесс. Одним из существенных преимуществ, которое отличает его от других вариантов, является его удобный характер. Интеграция с распространенными пакетами аналитики данных, такими как Ndarray, позволяет легко использовать его вместе со знакомыми структурами.

Еще одно примечательное преимущество использования этого инструмента с открытым исходным кодом заключается в его экономичности; разработчики и аналитики могут использовать библиотеку без каких-либо сборов или ограничений прав использования. Кроме того, любой, кто заинтересован в улучшении программного обеспечения, может сделать это в рамках общественных усилий.

Кроме того, открытый исходный код означает быструю онлайн-поддержку со стороны других участников со всего мира через различные платформы, такие как форумы (например, stackoverflow), что делает решение проблем эффективным!

Настройка плоттеров

Чтобы в полной мере использовать возможности плоттеров, крайне важно убедиться, что мы правильно настроили нашу среду. Библиотека предлагает широкий спектр типов графиков, таких как линейные диаграммы, точечные диаграммы, гистограммы и круговые диаграммы; однако без надлежащей настройки эти функции остаются недоступными. К счастью для всех нас, настройка плоттеров не требует усилий — просто запустите команду в блокноте Jupyter, и все готово!

:dep plotters = { version = "^0.3.5", default_features = false, features = ["evcxr", "all_series", "all_elements"] }

После импорта в рабочую область вашего проекта или в сеанс записной книжки плоттеры позволяют вам изучить широкий спектр параметров настройки, специально адаптированных к вашим потребностям, независимо от того, требуются ли простые или сложные графики.

Однолинейные графики

Линейные графики — это основной инструмент визуализации в библиотеке Plotters, который позволяет нам представлять точки данных, соединенные прямыми линиями. В этом разделе мы рассмотрим концепцию однолинейных графиков, которые включают использование структуры LineSeries для создания визуализаций с одной линией.

Структура LineSeries в Plotters широко используется для визуализации данных, особенно при создании однолинейных графиков. Такие графики идеально подходят для иллюстрации корреляций между двумя переменными или выделения закономерностей в данных временных рядов.

Чтобы создать одномерный график с помощью плоттеров, начните с импорта библиотеки и использования ее функции draw_series вместе со структурой LineSeries для построения линейной диаграммы с назначенным набором данных. . Например, если мы хотим отобразить одномерные данные с помощью простого графика, вот как вы можете использовать функцию draw_series:

evcxr_figure((640, 240), |root| {
    let mut chart = ChartBuilder::on(&root)
        .build_cartesian_2d(0f32..5f32, 0f32..5f32)?;
    let x_axis = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0];
    chart.draw_series(LineSeries::new(
        x_axis.map(|x| (x, x)),
        &RED,
    ))?;
    Ok(())
}).style("width:100%")

В приведенном выше коде у нас есть массив x, представляющий обе координаты, x и y. Двигаясь дальше, давайте рассмотрим другой пример, в котором мы используем массив Ndarray для представления данных для однолинейного графика:

evcxr_figure((640, 240), |root| {
    let mut chart = ChartBuilder::on(&root)
        .build_cartesian_2d(0f32..7f32, 0f32..7f32)?;
    
    let x_axis = Array::range(1., 7., 1.);
    
    chart.draw_series(LineSeries::new(
        x_axis.into_raw_vec().into_iter().map(|x| (x, x)),
        &RED,
    ))?;
    Ok(())
}).style("width:100%")

Двигаясь дальше, давайте визуализируем квадратичный график, представленный уравнением y = f(x) = x³. Вот соответствующий код:

let points_coordinates: Vec<(f32, f32)> = {
    let x_axis = vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0];
    let quadratic: Vec<f32> = x_axis.iter().map(|x| i32::pow(*x as i32, 3) as f32).collect::<Vec<f32>>();
    x_axis.into_iter().zip(quadratic).collect()
};
points_coordinates

// Output

// [(1.0, 1.0), (2.0, 8.0), (3.0, 27.0), (4.0, 64.0), (5.0, 125.0), (6.0, 216.0)]

Теперь нам нужно построить этот вектор следующим образом:

evcxr_figure((640, 240), |root| {
    let mut chart = ChartBuilder::on(&root)
        .build_cartesian_2d(0f32..7f32, 0f32..220f32)?;

    chart.draw_series(LineSeries::new(
        points_coordinates.iter().map(|(x, y)| (*x, *y)),
        &RED,
    ))?;
    Ok(())
}).style("width:100%")

Таким образом, линейные графики в плоттерах предлагают превосходный подход к иллюстрации корреляций и тенденций в наборах данных. Мы можем создавать информативные, но увлекательные представления нашей информации, используя структуру LineSeries при работе с массивами/векторами значений x и значений y. Независимо от того, изучаете ли вы результаты научных исследований или анализируете бизнес-показатели, эти линейные графики являются незаменимыми инструментами для дальнейшего изучения вашего набора данных, а также эффективного обмена его идеями с другими.

Многострочные графики

Плоттеры предоставляют исключительную возможность отображать несколько графиков в одном выводе, что позволяет нам одновременно отображать несколько кривых в одной визуализации. Это замечательное свойство облегчает сравнение и анализ наборов данных. Чтобы углубиться в это понятие, давайте рассмотрим наглядный пример:

evcxr_figure((640, 240), |root| {
    let mut chart = ChartBuilder::on(&root)
        .build_cartesian_2d(0f32..7f32, 0f32..220f32)?;

    chart.draw_series(LineSeries::new(
        linear_coordinates.iter().map(|(x, y)| (*x, *y)),
        &RED,
    ))?;

    chart.draw_series(LineSeries::new(
        quadratic_coordinates.iter().map(|(x, y)| (*x, *y)),
        &GREEN,
    ))?;

    chart.draw_series(LineSeries::new(
        cubic_coordinates.iter().map(|(x, y)| (*x, *y)),
        &BLUE,
    ))?;

    Ok(())
}).style("width:100%")

Используя предоставленный фрагмент кода, мы можем легко создать множество кривых. Это достигается путем многократного вызова функции draw_series и определения значений x из массива в сочетании с соответствующими значениями y, полученными из различных математических выражений. После выполнения этого кода для целей наблюдения будет отображаться полный график, демонстрирующий все эти построенные кривые.

Давайте рассмотрим еще один пример, демонстрирующий адаптивность многострочных графиков. Обратите внимание на следующий фрагмент кода:

let points_coordinates: Vec<(f32, f32)> = {
    let x_y_axes = array!([[1., 2., 3., 4.], [1., 2., 3., 4.]]);
    let x_axis: Vec<f32> = x_y_axes.slice(s![0, 0, ..]).to_vec();
    let y_axis: Vec<f32> = x_y_axes.slice(s![0, 1, ..]).to_vec();
    x_axis.into_iter().zip(y_axis).collect()
};

// [(1.0, 1.0), (2.0, 2.0), (3.0, 3.0), (4.0, 4.0)]

evcxr_figure((640, 240), |root| {
    let mut chart = ChartBuilder::on(&root)
        .build_cartesian_2d(0f32..5f32, 0f32..5f32)?;

    chart.draw_series(LineSeries::new(
        points_coordinates.iter().map(|(x, y)| (*x, *y)),
        &RED,
    ))?;

    Ok(())
}).style("width:100%")

Фрагмент кода включает в себя массив Ndarray x с двумя измерениями, содержащий различные наборы данных. Каждая строка обозначает уникальные значения. Когда функция draw_series вызывается для всего массива, плоттеры воспринимают его как несколько кривых, которые должны быть построены одновременно. Результат демонстрирует оба набора данных рядом друг с другом для легкого сравнения и анализа их закономерностей, тенденций или любых других примечательных особенностей интуитивно понятным способом, который позволяет нам делать значимые выводы из них визуально без особых усилий.

Чтобы продемонстрировать адаптивность многострочных графиков, мы можем создать визуальное представление, используя произвольные данные. Обратите внимание на этот фрагмент кода в качестве иллюстрации:

let random_samples: Vec<(f32, f32)> = {
    let x_y_axes = Array::random((2, 5), Uniform::new(0., 1.));
    let x_axis: Vec<f32> = x_y_axes.slice(s![0, ..]).to_vec();
    let y_axis: Vec<f32> = x_y_axes.slice(s![0, ..]).to_vec();
    x_axis.into_iter().zip(y_axis).collect()
};

random_samples

evcxr_figure((640, 240), |root| {
    let mut chart = ChartBuilder::on(&root)
        .build_cartesian_2d(0f32..1f32, 0f32..1f32)?;

    chart.draw_series(LineSeries::new(
        random_samples.iter().map(|(x, y)| (*x, *y)),
        &RED,
    ))?;

    Ok(())
}).style("width:100%")

В этом фрагменте кода мы использовали функцию Ndarray Array::random для создания двумерного массива данных, который заполняется произвольными значениями. Каждый раз, когда вы используете этот метод, он генерирует эксклюзивный набор точек данных. Распечатав полученный массив, можно внимательно изучить эти случайные числа. Вызов draw_series отображает обе строки из нашего набора данных в виде отдельных кривых на одном графике. Поскольку каждое выполнение приводит к различным рандомизированным результатам, каждая сгенерированная диаграмма будет уникальной и внесет некоторую непредсказуемость и разнообразие в ваш опыт визуализации.

Подводя итог, можно сказать, что возможность визуализировать несколько графиков в одном выводе с помощью плоттеров — это мощная функция для исследования и анализа данных. Будь то построение отдельных кривых, сравнение наборов данных или использование случайных данных, многолинейные графики обеспечивают исчерпывающее представление имеющейся информации. Используя функции плоттеров и экспериментируя с различными источниками данных, вы можете создавать впечатляющие визуализации, которые облегчают понимание и принятие решений.

Сетка, оси и метки

В мире визуализации данных очень важно иметь возможность представлять сетку на графике. Библиотека плоттеров позволяет нам добиться этого, включив функцию сетки. Просто включив оператор chart.configure_mesh().draw()?; в наш код, мы можем повысить визуальную привлекательность и ясность наших графиков.

evcxr_figure((640, 240), |root| {
    let mut chart = ChartBuilder::on(&root)
        .build_cartesian_2d(0f32..1f32, 0f32..1f32)?;

    chart.configure_mesh().draw()?;

    Ok(())
}).style("width:100%")

Строка ChartBuilder::on(&root).build_cartesian_2d(0f32..1f32, 0f32..1f32)?; позволяет нам вручную установить пределы оси X от 0 до 1 и оси Y от 0 до 1. Указав эти диапазоны, мы имеем точный контроль над отображаемой областью нашего графика, гарантируя, что наиболее соответствующие точки данных подчеркнуты.

Чтобы улучшить ясность и понимание наших графиков, важно предоставить правильные метки для осей и описательный заголовок. В качестве примера рассмотрим следующий фрагмент кода:

evcxr_figure((640, 480), |root| {
    let mut chart = ChartBuilder::on(&root)
        .caption("Plot Demo", ("Arial", 20).into_font())
        .x_label_area_size(50)
        .y_label_area_size(50)
        .build_cartesian_2d(0f32..1f32, 0f32..1f32)?;
    
    chart.configure_mesh()
        .x_desc("x = Array::range(1., 7., 0.1);")
        .y_desc("y = f(x)")
        .draw()?;
    
    Ok(())
}).style("width: 60%")

В этом коде мы добавили оператор chart.configure_mesh().x_desc(“x = Array::range(1., 7., 1.);”).y_desc(“y = f(x)”).draw()?;, чтобы обогатить наш график значимыми аннотациями. Включая x_desc(“x = Array::range(1., 7., 1.);”), мы помечаем ось X кратким описанием отображаемых данных. Точно так же y_desc(“y = f(x)”) присваивает метку оси Y, указывающую на функциональную взаимосвязь. Кроме того, Caption(“Plot Demo”, (“Arial”, 20).into_font()) обеспечивает информативный заголовок, чтобы дать контекст сюжету. Эти элементы в совокупности улучшают интерпретируемость визуализации, гарантируя, что зрители могут легко понять цель и содержание сюжетов.

Помимо меток и заголовков, плоттеры позволяют нам создавать легенду, чтобы различать несколько кривых на графике. Передав аргумент для параметра метки в функцию label и впоследствии вызвав функцию legend, мы можем сгенерировать легенду. Рассмотрим следующий пример кода:

evcxr_figure((640, 480), |root| {
    let mut chart = ChartBuilder::on(&root)
        .caption("Plot Demo", ("Arial", 20).into_font())
        .x_label_area_size(50)
        .y_label_area_size(50)
        .build_cartesian_2d(1f32..7f32, 1f32..14f32)?;
    
    let x = Array::range(1., 7., 0.1);
    
    chart.configure_mesh()
        .x_desc("x = Array::range(1., 7., 1.);")
        .y_desc("y = f(x)")
        .draw()?;

    chart.draw_series(LineSeries::new(
        x.iter().map(|x| (*x, *x)),
        &RED
    )).unwrap()
        .label("y = x")
        .legend(|(x,y)| PathElement::new(vec![(x,y), (x + 20,y)], &RED));
    
    chart.draw_series(LineSeries::new(
        x.iter().map(|x| (*x, *x * 2.0)),
        &GREEN
    )).unwrap()
        .label("y = 2 * x")
        .legend(|(x,y)| PathElement::new(vec![(x,y), (x + 20,y)], &GREEN));

    chart.configure_series_labels()
        .background_style(&WHITE)
        .border_style(&BLACK)
        .draw()?;

    Ok(())
}).style("width: 60%")

Выполняя этот код, мы создаем легенду, соответствующую различным кривым на нашем графике. Функция legend() автоматически создает легенду на основе меток, предоставленных после вызова функции draw_series(). Это помогает зрителям идентифицировать и различать различные отображаемые функции. В сочетании с сеткой, метками осей и заголовком легенда повышает общую удобочитаемость и понимание графика.

По умолчанию поле легенды располагается в середине справа графика. Однако, если мы предпочитаем изменить расположение поля легенды, мы можем сделать это, указав параметр положения SeriesLabelPosition в функции position. Давайте соответствующим образом изменим наш фрагмент кода:

evcxr_figure((640, 480), |root| {
    let mut chart = ChartBuilder::on(&root)
        .caption("Plot Demo", ("Arial", 20).into_font())
        .x_label_area_size(50)
        .y_label_area_size(50)
        .build_cartesian_2d(1f32..7f32, 1f32..14f32)?;
    
    let x = Array::range(1., 7., 0.1);
    
    chart.configure_mesh()
        .x_desc("x = Array::range(1., 7., 0.1);")
        .y_desc("y = f(x)")
        .draw()?;

    chart.draw_series(LineSeries::new(
        x.iter().map(|x| (*x, *x)),
        &RED
    )).unwrap()
        .label("y = x")
        .legend(|(x,y)| PathElement::new(vec![(x,y), (x + 20,y)], &RED));
    
    chart.draw_series(LineSeries::new(
        x.iter().map(|x| (*x, *x * 2.0)),
        &GREEN
    )).unwrap()
        .label("y = 2 * x")
        .legend(|(x,y)| PathElement::new(vec![(x,y), (x + 20,y)], &GREEN));

    chart.configure_series_labels()
        .position(SeriesLabelPosition::UpperMiddle)
        .background_style(&WHITE)
        .border_style(&BLACK)
        .draw()?;

    Ok(())
}).style("width: 60%")

Включив параметр position(SeriesLabelPosition::UpperMiddle) в функцию configure_series_labels, мы перемещаем поле легенды в верхнюю середину графика. Это позволяет точно настроить размещение легенды, гарантируя, что она не будет мешать построенным кривым или другим аннотациям. Возможность настроить местоположение легенды добавляет универсальности и эстетики нашему сюжету.

Понимая и используя эти функции в плоттерах, мы можем создавать визуально привлекательные и информативные графики, настраивать ограничения по осям, добавлять метки и заголовки, включать легенды и сохранять наши визуализации в виде файлов изображений. Эти возможности позволяют нам эффективно общаться и представлять наши данные убедительным и осмысленным образом.

Цвета и маркеры

Плоттеры предлагают широкий спектр стилей и маркеров для создания визуально привлекательных и понятных графиков. Стили позволяют изменить внешний вид линий, а маркеры помогают выделить определенные точки данных на графике. Комбинируя различные цвета, стили и маркеры с функциями плоттеров, вы можете создавать уникальные графики, точно соответствующие вашим требованиям.

Плоттеры предлагают расширенные цветовые карты, которые позволяют визуализировать сложные данные с помощью спектра цветов. С помощью параметра style Plotters вы можете выбрать из массива предустановленных цветовых карт или создать собственную персонализированную карту, используя встроенную структуру, например RGBColor . Этот параметр оказывается особенно полезным при представлении данных, охватывающих обширные диапазоны значений или подчеркивающих определенные линии графика или любую другую форму. Вы можете обратиться к полной палитре для различных значений цвета RGB.

evcxr_figure((640, 480), |root| {
    let mut chart = ChartBuilder::on(&root)
        .caption("Plot Demo", ("Arial", 20).into_font())
        .x_label_area_size(50)
        .y_label_area_size(50)
        .build_cartesian_2d(1f32..7f32, 1f32..14f32)?;
    
    let x = Array::range(1., 7., 0.1);
    
    chart.configure_mesh()
        .x_desc("x = Array::range(1., 7., 0.1);")
        .y_desc("y = f(x)")
        .draw()?;

    chart.draw_series(LineSeries::new(
        x.iter().map(|x| (*x, *x)),
        &RGBColor(0,0,255) // red: 0, green: 0, blue: 255 -> the color is blue 
    ))?;
    
    Ok(())
}).style("width: 60%")

В этом примере мы изменили цвет линии на синий. Вы также можете использовать другие цветовые форматы, такие как HSLColor, чтобы указать собственные цвета с помощью значений спектра HSL.

Чтобы повысить визуальную привлекательность ваших линейных графиков в плоттерах, рассмотрите возможность включения маркеров для представления отдельных символов для каждого графика. Если вам нужен индивидуальный подход, есть несколько способов настроить эти маркеры. Во-первых, мы можем использовать метод draw_series, дважды отображая ваши данные с помощью стиля маркера, такого как размер и цвет, в зависимости от личных предпочтений или конкретных характеристик набора данных.

evcxr_figure((640, 480), |root| {
    let mut chart = ChartBuilder::on(&root)
        .caption("Plot Demo", ("Arial", 20).into_font())
        .x_label_area_size(50)
        .y_label_area_size(50)
        .build_cartesian_2d(1f32..7f32, 1f32..8f32)?;
    
    let x = Array::range(1., 7., 0.1);
    
    chart.configure_mesh()
        .x_desc("x = Array::range(1., 7., 0.1);")
        .y_desc("y = f(x)")
        .draw()?;

    chart.draw_series(LineSeries::new(
        x.iter().map(|x| (*x, *x)),
        &RED
    ))?;

    chart.draw_series(x.map(|x| {
        EmptyElement::at((*x, *x))
        + Cross::new((0, 0), 2, GREEN) // coordinates relative to EmptyElement
    }))?;

    Ok(())
}).style("width: 60%")

В качестве альтернативы мы можем установить размер маркера, используя метод point_size, который позволяет создать маркер с заполненным или открытым кругом.

evcxr_figure((640, 480), |root| {
    let mut chart = ChartBuilder::on(&root)
        .caption("Plot Demo", ("Arial", 20).into_font())
        .x_label_area_size(50)
        .y_label_area_size(50)
        .build_cartesian_2d(1f32..7f32, 1f32..8f32)?;
    
    let x = Array::range(1., 7., 0.1);
    
    chart.configure_mesh()
        .x_desc("x = Array::range(1., 7., 0.1);")
        .y_desc("y = f(x)")
        .draw()?;

    chart.draw_series(LineSeries::new(
        x.iter().map(|x| (*x, *x)),
        &RED
    ).point_size(2))?; // open circle marker

    Ok(())
}).style("width: 60%")

Вы можете комбинировать все эти методы (например, цвета, маркеры, легенду), чтобы настроить визуализацию следующим образом:

evcxr_figure((640, 480), |root| {
    let mut chart = ChartBuilder::on(&root)
        .caption("Plot Demo", ("Arial", 20).into_font())
        .x_label_area_size(50)
        .y_label_area_size(50)
        .build_cartesian_2d(1f32..7f32, 1f32..342f32)?;
    
    let x = Array::range(1., 7., 0.1);
    
    chart.configure_mesh()
        .x_desc("x = Array::range(1., 7., 0.1);")
        .y_desc("y = f(x)")
        .draw()?;

    chart.draw_series(LineSeries::new(
        x.iter().map(|x| (*x, *x)),
        RED.filled()
    ).point_size(2)).unwrap()
        .label("y = x")
        .legend(|(x,y)| PathElement::new(vec![(x,y), (x + 20,y)], &RED));

    chart.draw_series(LineSeries::new(
        x.iter().map(|x| (*x, (*x).powi(3))),
        BLUE
    ).point_size(2)).unwrap()
        .label("y = x ^ 3")
        .legend(|(x,y)| PathElement::new(vec![(x,y), (x + 20,y)], &BLUE));

    chart.draw_series(LineSeries::new(
        x.iter().map(|x| (*x, (*x).powi(2))),
        &GREEN
    )).unwrap()
        .label("y = x ^ 2")
        .legend(|(x,y)| PathElement::new(vec![(x,y), (x + 20,y)], &GREEN));

    chart.draw_series(x.map(|x| {
        EmptyElement::at((*x, (*x).powi(2)))
        + Cross::new((0, 0), 2, WHITE) // coordinates relative to EmptyElement
    }))?;

    chart.configure_series_labels()
        .background_style(&WHITE)
        .border_style(&BLACK)
        .draw()?;

    Ok(())
}).style("width: 60%")

В целом, плоттеры предлагают простой и легкий способ персонализировать цвета и маркеры, позволяя создавать исключительные визуализации. Выбирая подходящие цветовые палитры, ваши графики могут легко передавать ценную информацию. Выбор правильного цвета и маркера может иметь решающее значение для успешной передачи вашего сообщения.

Подсюжеты

Техника построения подграфиков — это мощный способ отображения нескольких графиков в одном выводе. Этот метод оказывается особенно полезным, когда вы хотите сравнить разные наборы данных или продемонстрировать различные аспекты одного набора данных. С помощью плоттеров создание подграфиков становится легкой задачей, поскольку это позволяет вам создать макет сетки, в котором положение каждого последующего графика может быть указано относительно его предшественника.

Кроме того, каждый подграфик имеет настраиваемые характеристики, такие как заголовки и метки, которые позволяют пользователям легко адаптировать свои выходные данные в соответствии с конкретными потребностями. Построение подграфиков особенно удобно при работе со сложной информацией в контексте науки и анализа данных, поскольку оно помогает кратко, но эффективно передать важные выводы.

Для создания подграфиков в плоттерах можно использовать метод split_evenly, требующий одного параметра: кортежа, состоящего из количества строк и столбцов. Например, если вы хотите создать макет 1 x 2 для своих подграфиков при отображении данных на первом; затем используйте этот фрагмент кода:

let linear_coordinates: Vec<(f32, f32)> = {
    let x_y_axes = array!([[1., 2., 3., 4.], [1., 2., 3., 4.]]);
    let x_axis: Vec<f32> = x_y_axes.slice(s![0, 0, ..]).to_vec();
    let y_axis: Vec<f32> = x_y_axes.slice(s![0, 1, ..]).to_vec();
    x_axis.into_iter().zip(y_axis).collect()
};
let quadratic_coordinates: Vec<(f32, f32)> = {
    let x_y_axes = array!([[1., 2., 3., 4.], [1., 4., 9., 16.]]);
    let x_axis: Vec<f32> = x_y_axes.slice(s![0, 0, ..]).to_vec();
    let y_axis: Vec<f32> = x_y_axes.slice(s![0, 1, ..]).to_vec();
    x_axis.into_iter().zip(y_axis).collect()
};

evcxr_figure((640, 480), |root| {
    let sub_areas = root.split_evenly((1,2)); // 1x2 grid ( 1 row, 2 columns)

    let graphs = vec![
        ("y = x", linear_coordinates.clone(), &RED),
        ("y= x ^ 2", quadratic_coordinates.clone(), &GREEN),
    ];

    for ((idx, area), graph) in (1..).zip(sub_areas.iter()).zip(graphs.iter()) {
        let mut chart = ChartBuilder::on(&area)
            .caption(graph.0, ("Arial", 15).into_font())
            .x_label_area_size(40)
            .y_label_area_size(40)
            .build_cartesian_2d(0f32..5f32, 0f32..17f32)?;

        chart.draw_series(LineSeries::new(
            graph.1.iter().map(|(x, y)| (*x, *y)),
            graph.2,
        )).unwrap()
            .label(graph.0)
            .legend(|(x,y)| PathElement::new(vec![(x,y), (x + 20,y)], &GREEN));

        chart.configure_mesh()
            .y_labels(10)
            .light_line_style(&TRANSPARENT)
            .disable_x_mesh()
            .x_desc("x = Array::range(1., 7., 0.1);")
            .y_desc(graph.0)
            .draw()?;
    }

    Ok(())
}).style("width:100%")

Это создаст сетку 1x2 подграфиков и отобразит данные в обоих подграфиках с указанным заголовком и метками осей. Аргумент кортежа, переданный в split_evenly, представляет сетку (1 строка и 2 столбца). В плоттерах существует множество способов создания подграфиков с использованием split_vertically, split_horizontally, split_evenly и split_by_breakpoints

Используя возможности плоттеров для создания подграфиков, можно добиться потрясающих визуализаций, которые помогают в общении, четко и точно представляя идеи.

Планки ошибок

Для точного представления данных крайне важно признать возможность ошибки и сделать ее прозрачной. Этого можно достичь за счет использования планок погрешностей — графических представлений, отображающих изменчивость измерений и указывающих уровни неопределенности. Плоттеры предлагают простое решение с помощью функции ErrorBar, позволяющей пользователям добавлять эти важные визуальные средства к любому графику, указывая координаты x/y, цвет/стиль. предпочтения, а также предоставление соответствующих значений ошибок. Рассмотрим следующий фрагмент кода:

evcxr_figure((640, 480), |root| {
    let mut chart = ChartBuilder::on(&root)
        .caption("Vertical Error Bars Plot", ("Arial", 20).into_font())
        .x_label_area_size(50)
        .y_label_area_size(50)
        .build_cartesian_2d(1f32..7f32, 1f32..50f32)?;
    
    let x = Array::range(1., 7., 0.1);

    chart.configure_mesh()
        .x_desc("x = Array::range(1., 7., 0.1);")
        .y_desc("y = f(x)")
        .draw()?;

    chart.draw_series(LineSeries::new(
        x.iter().map(|x| (*x, (*x as f32).powi(2))),
        &GREEN
    )).unwrap()
        .label("y = x ^ 2")
        .legend(|(x,y)| PathElement::new(vec![(x,y), (x + 20,y)], &GREEN));
  
    chart.draw_series(x.map(|x| {
        ErrorBar::new_vertical(*x, (*x as f32).powi(2) - 1.5, (*x as f32).powi(2), (*x as f32).powi(2) + 1.4, RED.filled(), 2)
    })).unwrap();

    chart.configure_series_labels()
        .background_style(&WHITE)
        .border_style(&BLACK)
        .draw()?;

    Ok(())
}).style("width: 100%")

В этом примере мы решили отобразить ошибку на оси Y, поскольку она обычно более распространена. Предыдущее изображение является визуальным представлением наших данных и демонстрирует отдельные полосы ошибок, окружающие каждую точку данных. Эти столбцы показывают диапазон значений, которые вероятны в пределах определенного уровня достоверности; более длинные полосы означают большую неопределенность измерения.

Однако могут быть случаи, когда отображение данных об ошибках на обеих осях может оказаться полезным, особенно при работе с временными рядами или экспериментальными данными, содержащими несколько независимых переменных. В таких случаях будет достаточно использования метода ErrorBar::new_horizontal и передачи массива ошибок по оси X (аналогично делается для ошибок по оси Y).

evcxr_figure((640, 480), |root| {
    let mut chart = ChartBuilder::on(&root)
        .caption("Horizontal Error Bars Plot", ("Arial", 20).into_font())
        .x_label_area_size(50)
        .y_label_area_size(50)
        .build_cartesian_2d(1f32..7f32, 1f32..50f32)?;
    
    let x = Array::range(1., 7., 0.1);

    chart.configure_mesh()
        .x_desc("x = Array::range(1., 7., 0.1);")
        .y_desc("y = f(x)")
        .draw()?;

    chart.draw_series(LineSeries::new(
        x.iter().map(|x| (*x, (*x as f32).powi(2))),
        &GREEN
    )).unwrap()
        .label("y = x ^ 2")
        .legend(|(x,y)| PathElement::new(vec![(x,y), (x + 20,y)], &GREEN));
  
    chart.draw_series(x.map(|x| {
        ErrorBar::new_horizontal((*x as f32).powi(2), *x - 0.3, *x, *x + 0.3, RED.filled(), 2)
    })).unwrap();

    chart.configure_series_labels()
        .background_style(&WHITE)
        .border_style(&BLACK)
        .draw()?;

    Ok(())
}).style("width: 100%")

Включая такие элементы в ваши визуализации — будь то ученый, который делится результатами исследований, или бизнес-аналитик, отображающий данные о продажах, — аудитория может лучше понять любую неопределенность, связанную с представленной информацией. Таким образом, использование этой важной функции гарантирует точную передачу точных деталей, сохраняя при этом ясность презентаций без путаницы, вызванной ошибками в наборах данных, представленных графически с использованием функций плоттеров, таких как полосы погрешностей!

Точечная диаграмма

Диаграммы рассеивания служат важным инструментом для визуализации данных и понимания взаимосвязи между двумя переменными. Плоттеры позволяют легко создавать точечные диаграммы в Rust, назначая одну переменную оси X, а другую — оси Y, и нанесение каждой точки на соответствующие координаты. Управляя цветами и размерами точек, вы можете представить дополнительные измерения в своем наборе данных.

Основное преимущество использования точечных диаграмм заключается в том, что они выявляют закономерности или кластеры в данных, которые могут быть не видны только из таблиц или диаграмм. Выбросы также легко идентифицировать с помощью этого метода.

Кроме того, эти графики имеют интуитивно понятный характер, что позволяет любому, независимо от статистического опыта, быстро понять взаимосвязь между различными аспектами, что делает их полезными средствами коммуникации при представлении результатов.

Следующий фрагмент кода сгенерирует точечную диаграмму образцов данных с равномерным распределением:

evcxr_figure((640, 480), |root| {
    _ = root.fill(&WHITE);

    let mut chart = ChartBuilder::on(&root)
        .caption("Uniform Distribution Scatter Plot", ("Arial", 20).into_font())
        .x_label_area_size(40)
        .y_label_area_size(40)
        .build_cartesian_2d(0f32..1f32, 0f32..1f32)?;

    chart.configure_mesh()
        .disable_x_mesh()
        .disable_y_mesh()
        .y_labels(5)
        .x_label_formatter(&|x| format!("{:.1}", *x as f64 / 100.0))
        .y_label_formatter(&|y| format!("{}%", (*y * 100.0) as u32))
        .draw()?;

    let _ = chart.draw_series(random_samples.iter().map(|(x,y)| Circle::new((*x,*y), 3, GREEN.filled())));
    
    Ok(())
}).style("width:100%")

Полученная диаграмма рассеяния выглядит следующим образом:

Таким образом, точечные диаграммы предлагают мощные возможности визуализации, позволяющие нам лучше понимать наши наборы данных, а также предоставляющие простые способы обмена информацией с другими, в основном благодаря простым в использовании функциям, предоставляемым функциями библиотеки плоттеров. в среде языка программирования Rust!

Гистограмма

Гистограммы являются бесценным активом, когда речь идет об анализе распределения данных. Они предлагают визуальное представление о том, как информация распределяется по различным категориям или корзинам, облегчая нам понимание и интерпретацию сложных наборов данных. Плоттеры упрощают этот процесс, используя функцию Histogram::vertical с линейными массивами, которые группируют точки данных в столбцы, представляющие частоту на размер ячейки.

Например, если нам нужно построить случайно сгенерированное равномерное распределение, создание гистограмм будет отображать частоту каждого возможного результата в деталях, выявляя любые закономерности или тенденции, присутствующие в наборе данных. Анализ этих графиков может помочь раскрыть ценную информацию об основных распределениях, таких как демографические данные возрастных групп населения, уровни освещенности, зафиксированные на фотографиях, или ежемесячные нормы осадков, наблюдаемые в городах.

Следующий фрагмент кода является примером построения случайно сгенерированных выборок данных равномерного распределения:

evcxr_figure((640, 480), |root| {
    let mut chart = ChartBuilder::on(&root)
        .caption("Histogram", ("Arial", 20).into_font())
        .x_label_area_size(50)
        .y_label_area_size(50)
        .build_cartesian_2d(0u32..100u32, 0f64..0.5f64)?;

    chart.configure_mesh()
        .disable_x_mesh()
        .disable_y_mesh()
        .y_labels(5)
        .x_label_formatter(&|x| format!("{:.1}", *x as f64 / 100.0))
        .y_label_formatter(&|y| format!("{}%", (*y * 100.0) as u32))
        .draw()?;

    let hist = Histogram::vertical(&chart)
        .style(RED.filled())
        .margin(0)
        .data(random_samples.iter().map(|(x,_)| ((x*100.0) as u32, 0.01)));

    let _ = chart.draw_series(hist);
    
    Ok(())
}).style("width:100%")

Полученная гистограмма выглядит следующим образом:

Таким образом, гистограммы предоставляют мощные инструменты для получения информации о различных наборах данных и точного определения критических факторов, влияющих на них с течением времени. Использование функций плоттеров, таких как настраиваемые размеры контейнеров, специально адаптированные к нашим потребностям, позволяет нам более гибко интерпретировать большие объемы информации быстро, не жертвуя точностью!

Заключение

В этой статье подчеркивается важность визуализаций и возможности настройки плоттеров в соответствии с различными потребностями. Плоттеры оказались бесценными при создании различных типов графиков, таких как однолинейные или многолинейные графики, точечные диаграммы и гистограммы. Кроме того, мы узнали о настройке функций, таких как выбор макета для цветовых линий, маркеров, легенд и т. д.

Имея под рукой новые знания, вы сможете легко и уверенно ориентироваться в различных функциях плоттеров. Эффективное использование этих методов улучшит ваше понимание данных и позволит лучше сообщать о результатах.

В следующей серии статей, особенно во второй части, мы рассмотрим захватывающие визуализации данных, включая, помимо прочего, круговые диаграммы и трехмерные визуализации. Цель состоит в том, чтобы дать вам возможность стать опытным визуальным рассказчиком с вашими данными, раскрывая скрытые идеи, как никогда раньше!

Заключительное примечание

Завершая этот урок, я хотел бы выразить искреннюю признательность всем тем, кто посвятил свое время и энергию его завершению. Было очень приятно продемонстрировать с вами исключительные возможности языка программирования Rust.

Будучи увлеченным наукой о данных, я обещаю вам, что с этого момента я буду писать по крайней мере одну всеобъемлющую статью каждую неделю или около того на связанные темы. Если вам интересно быть в курсе моей работы, подумайте о том, чтобы связаться со мной на различных платформах социальных сетей или связаться напрямую, если вам нужна помощь.

Спасибо!

Ресурсы