Machinelearning: Machine Learning for .NET

Machine Learning for .NET

ML.NET is a cross-platform open-source machine learning (ML) framework for .NET.

ML.NET allows developers to easily build, train, deploy, and consume custom models in their .NET applications without requiring prior expertise in developing machine learning models or experience with other programming languages like Python or R. The framework provides data loading from files and databases, enables data transformations, and includes many ML algorithms.

With ML.NET, you can train models for a variety of scenarios, like classification, forecasting, and anomaly detection.

You can also consume both TensorFlow and ONNX models within ML.NET which makes the framework more extensible and expands the number of supported scenarios.

Getting started with machine learning and ML.NET

• Learn more about the basics of ML.NET.
• Build your first ML.NET model by following our ML.NET Getting Started tutorial.
• Check out our documentation and tutorials.
• See the API Reference documentation.
• Clone our ML.NET Samples GitHub repo and run some sample apps.
• Take a look at some ML.NET Community Samples.
• Watch some videos on the ML.NET videos YouTube playlist.

Roadmap

Take a look at ML.NET's Roadmap to see what the team plans to work on in the next year.

Operating systems and processor architectures supported by ML.NET

ML.NET runs on Windows, Linux, and macOS using .NET Core, or Windows using .NET Framework.

ML.NET also runs on ARM64, Apple M1, and Blazor Web Assembly. However, there are some limitations.

64-bit is supported on all platforms. 32-bit is supported on Windows, except for TensorFlow and LightGBM related functionality.

ML.NET NuGet packages status

Release notes

Check out the release notes to see what's new. You can also read the blog posts for more details about each release.

Using ML.NET packages

First, ensure you have installed .NET Core 2.1 or later. ML.NET also works on the .NET Framework 4.6.1 or later, but 4.7.2 or later is recommended.

Once you have an app, you can install the ML.NET NuGet package from the .NET Core CLI using:

dotnet add package Microsoft.ML

or from the NuGet Package Manager:

Install-Package Microsoft.ML

Alternatively, you can add the Microsoft.ML package from within Visual Studio's NuGet package manager or via Paket.

Daily NuGet builds of the project are also available in our Azure DevOps feed:

https://pkgs.dev.azure.com/dnceng/public/_packaging/dotnet-libraries/nuget/v3/index.json

Building ML.NET (For contributors building ML.NET open source code)

To build ML.NET from source please visit our developer guide.

	Debug	Release
CentOS
Ubuntu
macOS
Windows x64
Windows FullFramework
Windows x86
Windows NetCore3.1

Release process and versioning

Major releases of ML.NET are shipped once a year with the major .NET releases, starting with ML.NET 1.7 in November 2021 with .NET 6, then ML.NET 2.0 with .NET 7, etc. We will maintain release branches to optionally service ML.NET with bug fixes and/or minor features on the same cadence as .NET servicing.

Check out the Release Notes to see all of the past ML.NET releases.

Contributing

We welcome contributions! Please review our contribution guide.

Community

• Join our community on Discord.
• Tune into the .NET Machine Learning Community Standup every other Wednesday at 10AM Pacific Time.

This project has adopted the code of conduct defined by the Contributor Covenant to clarify expected behavior in our community. For more information, see the .NET Foundation Code of Conduct.

Code examples

Here is a code snippet for training a model to predict sentiment from text samples. You can find complete samples in the samples repo.

var dataPath = "sentiment.csv";
var mlContext = new MLContext();
var loader = mlContext.Data.CreateTextLoader(new[]
    {
        new TextLoader.Column("SentimentText", DataKind.String, 1),
        new TextLoader.Column("Label", DataKind.Boolean, 0),
    },
    hasHeader: true,
    separatorChar: ',');
var data = loader.Load(dataPath);
var learningPipeline = mlContext.Transforms.Text.FeaturizeText("Features", "SentimentText")
        .Append(mlContext.BinaryClassification.Trainers.FastTree());
var model = learningPipeline.Fit(data);

Now from the model we can make inferences (predictions):

var predictionEngine = mlContext.Model.CreatePredictionEngine<SentimentData, SentimentPrediction>(model);
var prediction = predictionEngine.Predict(new SentimentData
{
    SentimentText = "Today is a great day!"
});
Console.WriteLine("prediction: " + prediction.Prediction);

.NET Foundation

ML.NET is a part of the .NET Foundation.

Download Details:

Author: Dotnet
Source Code: https://github.com/dotnet/machinelearning 
License: MIT license

#machinelearning #algorithms #dotnet #ml 

ML Visuals Contains Figures & Templates Which You Can Reuse

ML Visuals

⚠️ Please note that I have halted giving editing access to the slides as I figure out how to best maintain the project going forward. You can still access the slides and make a copy of it for your own purposes.

ML Visuals is a new collaborative effort to help the machine learning community in improving science communication by providing free professional, compelling and adequate visuals and figures. Currently, we have over 100 figures (all open community contributions). You are free to use the visuals in your machine learning presentations or blog posts. You don’t need to ask permission to use any of the visuals but it will be nice if you can provide credit to the designer/author (author information found in the slide notes). Check out the versions of the visuals below.

This is a project made by the dair.ai community. The latest version of the Google slides can be found in this GitHub repository. Our community members will continue to add more common figures and basic elements in upcoming versions. Think of this as free and open artifacts and templates which you can freely and easily download, copy, distribute, reuse and customize to your own needs.

ML Visuals is now being used to power 100s of figures used by master/PhD students, papers (like this one), among other use cases.

How to Use?

Essentially, we are using Google Slides to maintain all visuals and figures (check the versions below). To add your own custom figures, simply add a new slide and reuse any of the basic visual components (remember to request edit permissions). You can also create your own copy of the slides and customize whatever you like. We encourage authors/designers to add their visuals here and allow others to reuse them. Make sure to include your author information (in the notes section of the slide) so that others can provide credit if they use the visuals elsewhere (e.g. blog/presentations). Also, provide a short description of your visual to help the user understand what it is about and how they can use it. If you need "Edit" permission, just click on the "request edit access" option under the "view only" toolbar (in Google Slides) or send me an email at ellfae@gmail.com.

Downloading a figure from any of the slides is easy. Just click on File→Download→(choose your format).

If you need help with customizing a figure or have an idea of something that could be valuable to others, we can help. Just open an issue here and we will do our best to come up with the visual. Thanks.

Feel free to reach out to me on Twitter for an invite to our Slack group.

Versions:

• Version 1.0

How to Contribute?

• You can check out our Project page to see all the ongoing tasks or issues related to this research project. Lookout for the main ml_visuals tag. Issues with the good first issue tag are good tasks to get started with.
• You can also just check the issues tab.
• You can ask anything related to this project in our Slack group
• Slack channel: #ml_visuals

Some ideas for figures to add to the Slides (issue)

•  Linear regression, single-layer neural network
•  Multilayer Perceptron with hidden layer
•  Backpropagation
•  Batch Normalization and alternatives
•  Computational Graphs
•  Dropout
•  CNN - padding, stride, pooling,...
•  LeNet
•  AlexNet
•  VGG
•  GoogleNet
•  ResNet
•  DenseNet
•  Memory Networks
•  RNN
•  Deep RNN
•  Bidirectional RNN
•  GRU
•  LSTM
•  Language RNN models
•  Backpropagation through time
•  Encoder-Decoder Architecture
•  Seq2seq with RNN encoder-decoder
•  Bearm search and other decoding strategies
•  Attention
•  Multi-head attention
•  Self-attention
•  Transformer
•  Word2vec/GloVe/Skip-gram/CBOW/BERT/GPT....
•  Common/Popular CV/NLP Tasks

List adopted from multiple resources including nlpoverview and d2l.ai which both contain a very solid syllabus.

Examples of Visuals

Download Details:

Author: Dair-ai
Source Code: https://github.com/dair-ai/ml-visuals 
License: MIT license

#machinelearning #design #naturallanguageprocessing #deeplearning

Mlflow: Open Source Platform for The Machine Learning Lifecycle

MLflow: A Machine Learning Lifecycle Platform

Please help us test the upcoming release of MLflow 2.0 by installing and testing the MLflow 2.0 RC!

Installation

pip install mlflow==2.0.0rc0

Documentation

MLflow 2.0.0rc0

MLflow is a platform to streamline machine learning development, including tracking experiments, packaging code into reproducible runs, and sharing and deploying models. MLflow offers a set of lightweight APIs that can be used with any existing machine learning application or library (TensorFlow, PyTorch, XGBoost, etc), wherever you currently run ML code (e.g. in notebooks, standalone applications or the cloud). MLflow's current components are:

• MLflow Tracking: An API to log parameters, code, and results in machine learning experiments and compare them using an interactive UI.
• MLflow Projects: A code packaging format for reproducible runs using Conda and Docker, so you can share your ML code with others.
• MLflow Models: A model packaging format and tools that let you easily deploy the same model (from any ML library) to batch and real-time scoring on platforms such as Docker, Apache Spark, Azure ML and AWS SageMaker.
• MLflow Model Registry: A centralized model store, set of APIs, and UI, to collaboratively manage the full lifecycle of MLflow Models.

Installing

Install MLflow from PyPI via pip install mlflow

MLflow requires conda to be on the PATH for the projects feature.

Nightly snapshots of MLflow master are also available here.

Install a lower dependency subset of MLflow from PyPI via pip install mlflow-skinny Extra dependencies can be added per desired scenario. For example, pip install mlflow-skinny pandas numpy allows for mlflow.pyfunc.log_model support.

Documentation

Official documentation for MLflow can be found at https://mlflow.org/docs/latest/index.html.

Roadmap

The current MLflow Roadmap is available at https://github.com/mlflow/mlflow/milestone/3. We are seeking contributions to all of our roadmap items with the help wanted label. Please see the Contributing section for more information.

Community

For help or questions about MLflow usage (e.g. "how do I do X?") see the docs or Stack Overflow.

To report a bug, file a documentation issue, or submit a feature request, please open a GitHub issue.

For release announcements and other discussions, please subscribe to our mailing list (mlflow-users@googlegroups.com) or join us on Slack.

Running a Sample App With the Tracking API

The programs in examples use the MLflow Tracking API. For instance, run:

python examples/quickstart/mlflow_tracking.py

This program will use MLflow Tracking API, which logs tracking data in ./mlruns. This can then be viewed with the Tracking UI.

Launching the Tracking UI

The MLflow Tracking UI will show runs logged in ./mlruns at http://localhost:5000. Start it with:

mlflow ui

Note: Running mlflow ui from within a clone of MLflow is not recommended - doing so will run the dev UI from source. We recommend running the UI from a different working directory, specifying a backend store via the --backend-store-uri option. Alternatively, see instructions for running the dev UI in the contributor guide.

Running a Project from a URI

The mlflow run command lets you run a project packaged with a MLproject file from a local path or a Git URI:

mlflow run examples/sklearn_elasticnet_wine -P alpha=0.4

mlflow run https://github.com/mlflow/mlflow-example.git -P alpha=0.4

See examples/sklearn_elasticnet_wine for a sample project with an MLproject file.

Saving and Serving Models

To illustrate managing models, the mlflow.sklearn package can log scikit-learn models as MLflow artifacts and then load them again for serving. There is an example training application in examples/sklearn_logistic_regression/train.py that you can run as follows:

$ python examples/sklearn_logistic_regression/train.py
Score: 0.666
Model saved in run <run-id>

$ mlflow models serve --model-uri runs:/<run-id>/model

$ curl -d '{"columns":[0],"index":[0,1],"data":[[1],[-1]]}' -H 'Content-Type: application/json'  localhost:5000/invocations

Note: If using MLflow skinny (pip install mlflow-skinny) for model serving, additional required dependencies (namely, flask) will need to be installed for the MLflow server to function.

Contributing

We happily welcome contributions to MLflow. We are also seeking contributions to items on the MLflow Roadmap. Please see our contribution guide to learn more about contributing to MLflow.

Download Details:

Author: mlflow
Source Code: https://github.com/mlflow/mlflow 
License: Apache-2.0 license

#machinelearning #ai #apache-spark #ml 

Deal with Categorical Data for Machine Learning

Check out this guide to implementing different types of encoding for categorical data, including a cheat sheet on when to use what type.

Source: https://www.kdnuggets.com

#ml #machine-learning 

Xử Lý Dữ Liệu Phân Loại Cho Học Máy

Hãy xem hướng dẫn này để triển khai các kiểu mã hóa khác nhau cho dữ liệu phân loại, bao gồm cả bảng gian lận về thời điểm sử dụng kiểu nào.

Trong blog này, chúng tôi sẽ khám phá và triển khai:

• Mã hóa một lần sử dụng:
  • Thư viện category_encoding của Python
  • Xử lý trước Scikit-learning
  • Gấu trúc 'get_dummies
• Mã hóa nhị phân
• Mã hóa tần số
• Mã hóa nhãn
• Mã hóa thông thường

Dữ liệu phân loại là gì?

Dữ liệu phân loại là một loại dữ liệu được sử dụng để nhóm các thông tin có đặc điểm giống nhau, trong khi dữ liệu số là loại dữ liệu thể hiện thông tin dưới dạng số.

Ví dụ về dữ liệu phân loại: giới tính

Tại sao chúng ta cần mã hóa?

• Hầu hết các thuật toán học máy không thể xử lý các biến phân loại trừ khi chúng tôi chuyển đổi chúng thành các giá trị số
• Nhiều hiệu suất của thuật toán thậm chí khác nhau dựa trên cách các biến phân loại được mã hóa

Các biến phân loại có thể được chia thành hai loại:

• Danh nghĩa: không có thứ tự cụ thể
• Thứ tự: có một số thứ tự giữa các giá trị

Chúng tôi cũng sẽ đề cập đến một bảng gian lận cho biết khi nào sử dụng loại mã hóa nào.

Phương pháp 1: Sử dụng Thư viện mã hóa danh mục của Python

category_encoders là một thư viện Python tuyệt vời cung cấp 15 lược đồ mã hóa khác nhau.

Đây là danh sách 15 kiểu mã hóa mà thư viện hỗ trợ:

• Mã hóa một lần
• Mã hóa nhãn
• Mã hóa thông thường
• Mã hóa Helmert
• Mã hóa nhị phân
• Mã hóa tần số
• Mã hóa trung bình
• Trọng lượng của mã hóa bằng chứng
• Mã hóa tỷ lệ xác suất
• Mã hóa băm
• Mã hóa sự khác biệt ngược
• Để lại một lần mã hóa
• Mã hóa James-Stein
• Mã hóa công cụ ước lượng M
• Bộ mã hóa nhiệt kế

Nhập thư viện:

import pandas as pd
import sklearn

pip install category_encoders

import category_encoders as ce

Tạo khung dữ liệu:

data = pd.DataFrame({ 'gender' : ['Male', 'Female', 'Male', 'Female', 'Female'],
                       'class' : ['A','B','C','D','A'],
                        'city' : ['Delhi','Gurugram','Delhi','Delhi','Gurugram'] })
data.head()

Triển khai mã hóa một lần qua category_encoder

Trong phương pháp này, mỗi danh mục được ánh xạ tới một vectơ có chứa 1 và 0 biểu thị sự hiện diện hoặc vắng mặt của đối tượng địa lý. Số lượng vectơ phụ thuộc vào số danh mục cho các đối tượng địa lý.

Tạo một đối tượng của bộ mã hóa một nóng:

ce_OHE = ce.OneHotEncoder(cols=['gender','city'])

data1 = ce_OHE.fit_transform(data)
data1.head()

Mã hóa nhị phân

Mã hóa nhị phân chuyển đổi một danh mục thành các chữ số nhị phân. Mỗi chữ số nhị phân tạo ra một cột tính năng.

ce_be = ce.BinaryEncoder(cols=['class']);

# transform the data
data_binary = ce_be.fit_transform(data["class"]);
data_binary

Tương tự, có 14 kiểu mã hóa khác được cung cấp bởi thư viện này.

Phương pháp 2: Sử dụng hình nộm của gấu trúc

pd.get_dummies(data,columns=["gender","city"])

Chúng ta có thể gán tiền tố nếu chúng ta muốn, nếu chúng ta không muốn mã hóa sử dụng mặc định.

pd.get_dummies(data,prefix=["gen","city"],columns=["gender","city"])

Phương pháp 3: Sử dụng Scikit-learning

Scikit-learning cũng có 15 loại mã hóa tích hợp khác nhau, có thể được truy cập từ sklearn.preprocessing.

Mã hóa một lần trong Scikit-learning

Trước tiên, hãy lấy danh sách các biến phân loại từ dữ liệu của chúng tôi:

s = (data.dtypes == 'object')
cols = list(s[s].index)

from sklearn.preprocessing import OneHotEncoder

ohe = OneHotEncoder(handle_unknown='ignore',sparse=False)

Đăng ký trên cột giới tính:

data_gender = pd.DataFrame(ohe.fit_transform(data[["gender"]]))

data_gender

Đăng ký trên cột thành phố:

data_city = pd.DataFrame(ohe.fit_transform(data[["city"]]))

data_city

Áp dụng trên cột lớp:

data_class = pd.DataFrame(ohe.fit_transform(data[["class"]]))

data_class

Điều này là do cột lớp có 4 giá trị duy nhất.

Áp dụng cho danh sách các biến phân loại:

data_cols = pd.DataFrame(ohe.fit_transform(data[cols]))

data_cols

Ở đây, 2 cột đầu tiên đại diện cho giới tính, 4 cột tiếp theo đại diện cho lớp và 2 cột còn lại đại diện cho thành phố.

Mã hóa nhãn Scikit-learning

Trong mã hóa nhãn, mỗi danh mục được gán một giá trị từ 1 đến N trong đó N là số danh mục cho đối tượng địa lý. Không có mối quan hệ hoặc thứ tự giữa các nhiệm vụ này.

from sklearn.preprocessing import LabelEncoder

le = LabelEncoder()
Label encoder takes no arguments
le_class = le.fit_transform(data[["class"]])

So sánh với mã hóa một nóng

data_class

Mã hóa thông thường

Các biến được mã hóa của mã hóa thứ tự giữ nguyên bản chất thứ tự (có thứ tự) của biến. Nó trông tương tự như mã hóa nhãn, sự khác biệt duy nhất là mã hóa nhãn không xem xét liệu một biến có thứ tự hay không; sau đó nó sẽ gán một chuỗi các số nguyên.

Ví dụ: Mã hóa thông thường sẽ gán các giá trị là Rất tốt (1) <Tốt (2) <Kém (3) <Kém hơn (4)

Đầu tiên, chúng ta cần gán thứ tự ban đầu của biến thông qua một từ điển.

temp = {'temperature' :['very cold', 'cold', 'warm', 'hot', 'very hot']}
df=pd.DataFrame(temp,columns=["temperature"])
temp_dict = {'very cold': 1,'cold': 2,'warm': 3,'hot': 4,"very hot":5}
df

Sau đó, chúng ta có thể ánh xạ từng hàng cho biến theo từ điển.

df["temp_ordinal"] = df.temperature.map(temp_dict)
df

Mã hóa tần số

Danh mục được chỉ định theo tần suất của các giá trị trong tổng số lô của nó.

data_freq = pd.DataFrame({'class' : ['A','B','C','D','A',"B","E","E","D","C","C","C","E","A","A"]})

Phân nhóm theo cột lớp:

fe = data_freq.groupby("class").size()

Chia theo độ dài:

fe_ = fe/len(data_freq)

Lập bản đồ và làm tròn số:

data_freq["data_fe"] = data_freq["class"].map(fe_).round(2)
data_freq

Trong bài viết này, chúng tôi đã xem 5 loại lược đồ mã hóa. Tương tự, có 10 loại mã hóa khác mà chúng tôi chưa xem xét:

• Mã hóa Helmert
• Mã hóa trung bình
• Trọng lượng của mã hóa bằng chứng
• Mã hóa tỷ lệ xác suất
• Mã hóa băm
• Mã hóa sự khác biệt ngược
• Để lại một lần mã hóa
• Mã hóa James-Stein
• Mã hóa công cụ ước lượng M
• Bộ mã hóa nhiệt kế

Phương pháp mã hóa nào là tốt nhất?

Không có phương pháp duy nhất nào hoạt động tốt nhất cho mọi vấn đề hoặc tập dữ liệu. Cá nhân tôi nghĩ rằng phương thức get_dummies có lợi thế về khả năng được triển khai rất dễ dàng.

Nếu bạn muốn đọc về tất cả 15 loại bảng mã, đây là một bài viết rất tốt để tham khảo .

Dưới đây là một bảng gian lận về thời điểm sử dụng loại mã hóa nào:

Nguồn:  https://www.kdnuggets.com

#ml #machine-learning 

Работа с категориальными данными для машинного обучения

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

В этом блоге мы рассмотрим и реализуем:

• Горячее кодирование с использованием:
  • Python-библиотека category_encoding
  • Scikit-learn предварительная обработка
  • get_dummies панд
• Двоичное кодирование
• Частотное кодирование
• Кодировка этикетки
• Порядковое кодирование

Что такое Категориальные данные?

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

Пример категорийных данных: пол

Зачем нам нужна кодировка?

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

Категориальные переменные можно разделить на две категории:

• Номинал: нет особого порядка
• Порядковый номер: есть некоторый порядок между значениями

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

Метод 1: использование библиотеки кодировщика категорий Python

category_encoders — это потрясающая библиотека Python, которая предоставляет 15 различных схем кодирования.

Вот список из 15 типов кодирования, поддерживаемых библиотекой:

• Горячее кодирование
• Кодировка этикетки
• Порядковое кодирование
• Кодировка Гельмерта
• Двоичное кодирование
• Частотное кодирование
• Среднее кодирование
• Вес доказательств Кодирование
• Кодирование отношения вероятностей
• Кодирование хеширования
• Обратное кодирование разницы
• Оставьте одно кодирование
• Кодировка Джеймса-Стейна
• Кодирование M-оценки
• Кодер термометра

Импорт библиотек:

import pandas as pd
import sklearn

pip install category_encoders

import category_encoders as ce

Создание кадра данных:

data = pd.DataFrame({ 'gender' : ['Male', 'Female', 'Male', 'Female', 'Female'],
                       'class' : ['A','B','C','D','A'],
                        'city' : ['Delhi','Gurugram','Delhi','Delhi','Gurugram'] })
data.head()

Реализация горячего кодирования через category_encoder

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

Создайте объект one-hot encoder:

ce_OHE = ce.OneHotEncoder(cols=['gender','city'])

data1 = ce_OHE.fit_transform(data)
data1.head()

Двоичное кодирование

Двоичное кодирование преобразует категорию в двоичные цифры. Каждая двоичная цифра создает один столбец признаков.

ce_be = ce.BinaryEncoder(cols=['class']);

# transform the data
data_binary = ce_be.fit_transform(data["class"]);
data_binary

Точно так же есть еще 14 типов кодирования, предоставляемых этой библиотекой.

Метод 2: использование манекенов Pandas Get

pd.get_dummies(data,columns=["gender","city"])

Мы можем назначить префикс, если мы хотим, если мы не хотим, чтобы кодировка использовала кодировку по умолчанию.

pd.get_dummies(data,prefix=["gen","city"],columns=["gender","city"])

Способ 3: Использование Scikit-learn

Scikit-learn также имеет 15 различных типов встроенных кодировщиков, доступ к которым можно получить из sklearn.preprocessing.

Scikit-learn Быстрое кодирование

Давайте сначала получим список категориальных переменных из наших данных:

s = (data.dtypes == 'object')
cols = list(s[s].index)

from sklearn.preprocessing import OneHotEncoder

ohe = OneHotEncoder(handle_unknown='ignore',sparse=False)

Применение в графе пола:

data_gender = pd.DataFrame(ohe.fit_transform(data[["gender"]]))

data_gender

Подача заявки на городскую колонку:

data_city = pd.DataFrame(ohe.fit_transform(data[["city"]]))

data_city

Применение в столбце класса:

data_class = pd.DataFrame(ohe.fit_transform(data[["class"]]))

data_class

Это связано с тем, что столбец класса имеет 4 уникальных значения.

Применительно к списку категориальных переменных:

data_cols = pd.DataFrame(ohe.fit_transform(data[cols]))

data_cols

Здесь первые 2 столбца представляют пол, следующие 4 столбца — класс, а оставшиеся 2 — город.

Scikit-learn Кодировка меток

При кодировании меток каждой категории присваивается значение от 1 до N, где N — количество категорий для функции. Между этими назначениями нет никакой связи или порядка.

from sklearn.preprocessing import LabelEncoder

le = LabelEncoder()
Label encoder takes no arguments
le_class = le.fit_transform(data[["class"]])

Сравнение с горячим кодированием

data_class

Порядковое кодирование

Закодированные переменные порядкового кодирования сохраняют порядковый (упорядоченный) характер переменной. Это похоже на кодирование меток, с той лишь разницей, что кодирование меток не учитывает, является ли переменная порядковой или нет; затем он назначит последовательность целых чисел.

Пример: порядковое кодирование будет присваивать значения как Очень хорошо (1) < Хорошо (2) < Плохо (3) < Хуже (4)

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

temp = {'temperature' :['very cold', 'cold', 'warm', 'hot', 'very hot']}
df=pd.DataFrame(temp,columns=["temperature"])
temp_dict = {'very cold': 1,'cold': 2,'warm': 3,'hot': 4,"very hot":5}
df

Затем мы можем сопоставить каждую строку для переменной в соответствии со словарем.

df["temp_ordinal"] = df.temperature.map(temp_dict)
df

Частотное кодирование

Категория присваивается по частоте значений в его общей партии.

data_freq = pd.DataFrame({'class' : ['A','B','C','D','A',"B","E","E","D","C","C","C","E","A","A"]})

Группировка по столбцу класса:

fe = data_freq.groupby("class").size()

Разделение по длине:

fe_ = fe/len(data_freq)

Отображение и округление:

data_freq["data_fe"] = data_freq["class"].map(fe_).round(2)
data_freq

В этой статье мы увидели 5 типов схем кодирования. Точно так же есть 10 других типов кодирования, которые мы не рассматривали:

• Кодировка Гельмерта
• Среднее кодирование
• Вес доказательств Кодирование
• Кодирование отношения вероятностей
• Кодирование хеширования
• Обратное кодирование разницы
• Оставьте одно кодирование
• Кодировка Джеймса-Стейна
• Кодирование M-оценки
• Кодер термометра

Какой метод кодирования лучше?

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

Если вы хотите прочитать обо всех 15 типах кодирования, вот очень хорошая статья, на которую можно сослаться .

Вот шпаргалка о том, когда и какой тип кодировки использовать:

Источник:  https://www.kdnuggets.com

#ml #machine-learning 

處理機器學習的分類數據

查看本指南以實現分類數據的不同類型編碼，包括關於何時使用何種類型的備忘單。

在這篇博客中，我們將探索和實現：

• One-hot 編碼使用：
  • Python 的 category_encoding 庫
  • Scikit-learn 預處理
  • 熊貓的 get_dummies
• 二進制編碼
• 頻率編碼
• 標籤編碼
• 序數編碼

什麼是分類數據？

分類數據是一種用於對具有相似特徵的信息進行分組的數據，而數值數據是一種以數字形式表達信息的數據。

分類數據示例：性別

為什麼我們需要編碼？

• 大多數機器學習算法無法處理分類變量，除非我們將它們轉換為數值
• 許多算法的性能甚至會根據分類變量的編碼方式而有所不同

分類變量可以分為兩類：

• 標稱：無特定順序
• 序數：值之間有某種順序

我們還將參考一份說明何時使用哪種編碼類型的備忘單。

方法一：使用Python的Category Encoder庫

category_encoders 是一個了不起的 Python 庫，它提供了 15 種不同的編碼方案。

以下是該庫支持的 15 種編碼類型的列表：

• 一鍵編碼
• 標籤編碼
• 序數編碼
• 赫爾默特編碼
• 二進制編碼
• 頻率編碼
• 平均編碼
• 證據編碼權重
• 概率比編碼
• 散列編碼
• 後向差分編碼
• 遺漏編碼
• 詹姆斯-斯坦編碼
• M-估計器編碼
• 溫度計編碼器

導入庫：

import pandas as pd
import sklearn

pip install category_encoders

import category_encoders as ce

創建數據框：

data = pd.DataFrame({ 'gender' : ['Male', 'Female', 'Male', 'Female', 'Female'],
                       'class' : ['A','B','C','D','A'],
                        'city' : ['Delhi','Gurugram','Delhi','Delhi','Gurugram'] })
data.head()

通過 category_encoder 實現 one-hot 編碼

在這種方法中，每個類別都映射到一個包含 1 和 0 的向量，表示該特徵的存在或不存在。向量的數量取決於特徵類別的數量。

創建 one-hot 編碼器的對象：

ce_OHE = ce.OneHotEncoder(cols=['gender','city'])

data1 = ce_OHE.fit_transform(data)
data1.head()

二進制編碼

二進制編碼將類別轉換為二進制數字。每個二進制數字創建一個特徵列。

ce_be = ce.BinaryEncoder(cols=['class']);

# transform the data
data_binary = ce_be.fit_transform(data["class"]);
data_binary

同樣，該庫還提供了另外 14 種編碼類型。

方法二：使用 Pandas 的 Get Dummies

pd.get_dummies(data,columns=["gender","city"])

如果我們願意，我們可以分配一個前綴，如果我們不希望編碼使用默認值。

pd.get_dummies(data,prefix=["gen","city"],columns=["gender","city"])

方法三：使用 Scikit-learn

Scikit-learn 還有 15 種不同類型的內置編碼器，可以從 sklearn.preprocessing 訪問。

Scikit-learn One-hot 編碼

讓我們首先從我們的數據中獲取分類變量列表：

s = (data.dtypes == 'object')
cols = list(s[s].index)

from sklearn.preprocessing import OneHotEncoder

ohe = OneHotEncoder(handle_unknown='ignore',sparse=False)

應用於性別列：

data_gender = pd.DataFrame(ohe.fit_transform(data[["gender"]]))

data_gender

申請城市欄：

data_city = pd.DataFrame(ohe.fit_transform(data[["city"]]))

data_city

應用於類列：

data_class = pd.DataFrame(ohe.fit_transform(data[["class"]]))

data_class

這是因為類列有 4 個唯一值。

應用於分類變量列表：

data_cols = pd.DataFrame(ohe.fit_transform(data[cols]))

data_cols

這裡前 2 列代表性別，接下來的 4 列代表類別，剩下的 2 列代表城市。

Scikit-learn 標籤編碼

在標籤編碼中，每個類別都被分配一個從 1 到 N 的值，其中 N 是特徵的類別數。這些分配之間沒有關係或順序。

from sklearn.preprocessing import LabelEncoder

le = LabelEncoder()
Label encoder takes no arguments
le_class = le.fit_transform(data[["class"]])

與 one-hot 編碼比較

data_class

序數編碼

序數編碼的編碼變量保留了變量的序數（有序）性質。它看起來類似於標籤編碼，唯一的區別是標籤編碼不考慮變量是否是序數；然後它將分配一個整數序列。

示例：序數編碼將賦值為非常好（1）<好（2）<壞（3）<更壞（4）

首先，我們需要通過字典來分配變量的原始順序。

temp = {'temperature' :['very cold', 'cold', 'warm', 'hot', 'very hot']}
df=pd.DataFrame(temp,columns=["temperature"])
temp_dict = {'very cold': 1,'cold': 2,'warm': 3,'hot': 4,"very hot":5}
df

然後我們可以根據字典映射變量的每一行。

df["temp_ordinal"] = df.temperature.map(temp_dict)
df

頻率編碼

該類別是根據其總批次中值的頻率分配的。

data_freq = pd.DataFrame({'class' : ['A','B','C','D','A',"B","E","E","D","C","C","C","E","A","A"]})

按類別列分組：

fe = data_freq.groupby("class").size()

按長度劃分：

fe_ = fe/len(data_freq)

映射和四捨五入：

data_freq["data_fe"] = data_freq["class"].map(fe_).round(2)
data_freq

在本文中，我們看到了 5 種編碼方案。同樣，還有 10 種其他類型的編碼我們沒有研究過：

• 赫爾默特編碼
• 平均編碼
• 證據編碼權重
• 概率比編碼
• 散列編碼
• 後向差分編碼
• 遺漏編碼
• 詹姆斯-斯坦編碼
• M-估計器編碼
• 溫度計編碼器

哪種編碼方法最好？

沒有一種方法最適合每個問題或數據集。我個人認為 get_dummies 方法的優勢在於它的實現非常容易。

如果你想了解所有 15 種編碼類型，這裡有一篇非常好的文章可以參考。

以下是關於何時使用何種編碼類型的備忘單：

來源：  https ://www.kdnuggets.com

#ml #machine-learning 

Traiter Les Données Catégorielles Pour L'apprentissage Automatique

Consultez ce guide pour mettre en œuvre différents types d'encodage pour les données catégorielles, y compris une feuille de triche sur quand utiliser quel type.

Dans ce blog, nous allons explorer et mettre en œuvre :

• Encodage à chaud utilisant :
  • La bibliothèque category_encoding de Python
  • Prétraitement Scikit-learn
  • Les get_dummies des pandas
• Encodage binaire
• Codage de fréquence
• Encodage des étiquettes
• Codage ordinal

Qu'est-ce que les données catégorielles ?

Les données catégorielles sont un type de données utilisé pour regrouper des informations ayant des caractéristiques similaires, tandis que les données numériques sont un type de données qui expriment des informations sous forme de nombres.

Exemple de données catégorielles : genre

Pourquoi avons-nous besoin d'encodage?

• La plupart des algorithmes d'apprentissage automatique ne peuvent pas gérer les variables catégorielles à moins que nous ne les convertissions en valeurs numériques
• Les performances de nombreux algorithmes varient même en fonction de la façon dont les variables catégorielles sont codées

Les variables catégorielles peuvent être divisées en deux catégories :

• Nominal : pas d'ordre particulier
• Ordinal : il y a un certain ordre entre les valeurs

Nous ferons également référence à une feuille de triche qui indique quand utiliser quel type d'encodage.

Méthode 1 : Utilisation de la bibliothèque d'encodeurs de catégories de Python

category_encoders est une bibliothèque Python étonnante qui fournit 15 schémas de codage différents.

Voici la liste des 15 types d'encodage pris en charge par la bibliothèque :

• Encodage à chaud
• Encodage des étiquettes
• Codage ordinal
• Codage Helmert
• Encodage binaire
• Codage de fréquence
• Codage moyen
• Codage du poids de la preuve
• Encodage du rapport de probabilité
• Encodage de hachage
• Codage de différence vers l'arrière
• Laisser un encodage
• Codage James-Stein
• Codage de l'estimateur M
• Thermomètre Encodeur

Importation de bibliothèques :

import pandas as pd
import sklearn

pip install category_encoders

import category_encoders as ce

Création d'un dataframe :

data = pd.DataFrame({ 'gender' : ['Male', 'Female', 'Male', 'Female', 'Female'],
                       'class' : ['A','B','C','D','A'],
                        'city' : ['Delhi','Gurugram','Delhi','Delhi','Gurugram'] })
data.head()

Implémentation d'un encodage à chaud via category_encoder

Dans cette méthode, chaque catégorie est mappée à un vecteur qui contient 1 et 0 indiquant la présence ou l'absence de la fonctionnalité. Le nombre de vecteurs dépend du nombre de catégories d'entités.

Créez un objet de l'encodeur one-hot :

ce_OHE = ce.OneHotEncoder(cols=['gender','city'])

data1 = ce_OHE.fit_transform(data)
data1.head()

Encodage binaire

L'encodage binaire convertit une catégorie en chiffres binaires. Chaque chiffre binaire crée une colonne de caractéristiques.

ce_be = ce.BinaryEncoder(cols=['class']);

# transform the data
data_binary = ce_be.fit_transform(data["class"]);
data_binary

De même, il existe 14 autres types d'encodage fournis par cette bibliothèque.

Méthode 2 : Utiliser les Pandas Get Dummies

pd.get_dummies(data,columns=["gender","city"])

Nous pouvons attribuer un préfixe si nous le voulons, si nous ne voulons pas que l'encodage utilise la valeur par défaut.

pd.get_dummies(data,prefix=["gen","city"],columns=["gender","city"])

Méthode 3 : Utiliser Scikit-learn

Scikit-learn dispose également de 15 types différents d'encodeurs intégrés, accessibles à partir de sklearn.preprocessing.

Encodage à chaud Scikit-learn

Commençons par obtenir la liste des variables catégorielles à partir de nos données :

s = (data.dtypes == 'object')
cols = list(s[s].index)

from sklearn.preprocessing import OneHotEncoder

ohe = OneHotEncoder(handle_unknown='ignore',sparse=False)

Application sur la colonne sexe :

data_gender = pd.DataFrame(ohe.fit_transform(data[["gender"]]))

data_gender

Application sur la colonne de la ville :

data_city = pd.DataFrame(ohe.fit_transform(data[["city"]]))

data_city

Application sur la colonne de classe :

data_class = pd.DataFrame(ohe.fit_transform(data[["class"]]))

data_class

C'est parce que la colonne de classe a 4 valeurs uniques.

Application à la liste des variables catégorielles :

data_cols = pd.DataFrame(ohe.fit_transform(data[cols]))

data_cols

Ici, les 2 premières colonnes représentent le sexe, les 4 colonnes suivantes représentent la classe et les 2 autres représentent la ville.

Encodage d'étiquettes Scikit-learn

Dans le codage d'étiquette, chaque catégorie se voit attribuer une valeur de 1 à N où N est le nombre de catégories pour la caractéristique. Il n'y a pas de relation ou d'ordre entre ces affectations.

from sklearn.preprocessing import LabelEncoder

le = LabelEncoder()
Label encoder takes no arguments
le_class = le.fit_transform(data[["class"]])

Comparaison avec l'encodage à chaud

data_class

Codage ordinal

Les variables codées du codage ordinal conservent la nature ordinale (ordonnée) de la variable. Cela ressemble au codage d'étiquette, la seule différence étant que le codage d'étiquette ne tient pas compte du fait qu'une variable est ordinale ou non ; il attribuera alors une suite d'entiers.

Exemple : l'encodage ordinal attribuera des valeurs telles que Très bon(1) < Bon(2) < Mauvais(3) < Pire(4)

Tout d'abord, nous devons attribuer l'ordre d'origine de la variable via un dictionnaire.

temp = {'temperature' :['very cold', 'cold', 'warm', 'hot', 'very hot']}
df=pd.DataFrame(temp,columns=["temperature"])
temp_dict = {'very cold': 1,'cold': 2,'warm': 3,'hot': 4,"very hot":5}
df

Ensuite, nous pouvons mapper chaque ligne pour la variable selon le dictionnaire.

df["temp_ordinal"] = df.temperature.map(temp_dict)
df

Codage de fréquence

La catégorie est attribuée en fonction de la fréquence des valeurs dans son lot total.

data_freq = pd.DataFrame({'class' : ['A','B','C','D','A',"B","E","E","D","C","C","C","E","A","A"]})

Regroupement par colonne de classe :

fe = data_freq.groupby("class").size()

Division par longueur :

fe_ = fe/len(data_freq)

Cartographie et arrondi :

data_freq["data_fe"] = data_freq["class"].map(fe_).round(2)
data_freq

Dans cet article, nous avons vu 5 types de schémas d'encodage. De même, il existe 10 autres types d'encodage que nous n'avons pas examinés :

• Codage Helmert
• Codage moyen
• Codage du poids de la preuve
• Encodage du rapport de probabilité
• Encodage de hachage
• Codage de différence vers l'arrière
• Laisser un encodage
• Codage James-Stein
• Codage de l'estimateur M
• Thermomètre Encodeur

Quelle méthode d'encodage est la meilleure ?

Il n'y a pas de méthode unique qui fonctionne le mieux pour chaque problème ou ensemble de données. Je pense personnellement que la méthode get_dummies a un avantage dans sa capacité à être implémentée très facilement.

Si vous voulez en savoir plus sur les 15 types d'encodage, voici un très bon article à consulter .

Voici un aide-mémoire sur quand utiliser quel type d'encodage :

Source :  https://www.kdnuggets.com

#ml #machine-learning 

Tratar Con Datos Categóricos Para El Aprendizaje Automático

Consulte esta guía para implementar diferentes tipos de codificación para datos categóricos, incluida una hoja de trucos sobre cuándo usar qué tipo.

En este blog exploraremos e implementaremos:

• Codificación One-hot usando:
  • Biblioteca de codificación de categorías de Python
  • Preprocesamiento Scikit-learn
  • Los maniquíes de los pandas
• Codificación binaria
• Codificación de frecuencia
• Codificación de etiquetas
• Codificación ordinal

¿Qué son los datos categóricos?

Los datos categóricos son un tipo de datos que se utilizan para agrupar información con características similares, mientras que los datos numéricos son un tipo de datos que expresan información en forma de números.

Ejemplo de datos categóricos: género

¿Por qué necesitamos codificación?

• La mayoría de los algoritmos de aprendizaje automático no pueden manejar variables categóricas a menos que las conviertamos en valores numéricos
• El rendimiento de muchos algoritmos incluso varía en función de cómo se codifican las variables categóricas.

Las variables categóricas se pueden dividir en dos categorías:

• Nominal: sin orden particular
• Ordinal: hay cierto orden entre los valores.

También nos referiremos a una hoja de trucos que muestra cuándo usar qué tipo de codificación.

Método 1: usar la biblioteca de codificadores de categorías de Python

category_encoders es una increíble biblioteca de Python que proporciona 15 esquemas de codificación diferentes.

Aquí está la lista de los 15 tipos de codificación que admite la biblioteca:

• Codificación One-hot
• Codificación de etiquetas
• Codificación ordinal
• Codificación Helmert
• Codificación binaria
• Codificación de frecuencia
• Codificación media
• Codificación del peso de la evidencia
• Codificación de la razón de probabilidad
• Codificación hash
• Codificación de diferencia hacia atrás
• Dejar una codificación
• Codificación James-Stein
• Codificación del estimador M
• Codificador de termómetro

Importación de bibliotecas:

import pandas as pd
import sklearn

pip install category_encoders

import category_encoders as ce

Creación de un marco de datos:

data = pd.DataFrame({ 'gender' : ['Male', 'Female', 'Male', 'Female', 'Female'],
                       'class' : ['A','B','C','D','A'],
                        'city' : ['Delhi','Gurugram','Delhi','Delhi','Gurugram'] })
data.head()

Implementación de codificación one-hot a través de category_encoder

En este método, cada categoría se asigna a un vector que contiene 1 y 0 que denotan la presencia o ausencia de la característica. El número de vectores depende del número de categorías de características.

Cree un objeto del codificador one-hot:

ce_OHE = ce.OneHotEncoder(cols=['gender','city'])

data1 = ce_OHE.fit_transform(data)
data1.head()

Codificación binaria

La codificación binaria convierte una categoría en dígitos binarios. Cada dígito binario crea una columna de características.

ce_be = ce.BinaryEncoder(cols=['class']);

# transform the data
data_binary = ce_be.fit_transform(data["class"]);
data_binary

Del mismo modo, hay otros 14 tipos de codificación proporcionados por esta biblioteca.

Método 2: Uso de los maniquíes de Pandas

pd.get_dummies(data,columns=["gender","city"])

Podemos asignar un prefijo si queremos, si no queremos que la codificación use la predeterminada.

pd.get_dummies(data,prefix=["gen","city"],columns=["gender","city"])

Método 3: Usar Scikit-learn

Scikit-learn también tiene 15 tipos diferentes de codificadores integrados, a los que se puede acceder desde sklearn.preprocessing.

Codificación Scikit-learn One-hot

Primero obtengamos la lista de variables categóricas de nuestros datos:

s = (data.dtypes == 'object')
cols = list(s[s].index)

from sklearn.preprocessing import OneHotEncoder

ohe = OneHotEncoder(handle_unknown='ignore',sparse=False)

Aplicando en la columna de género:

data_gender = pd.DataFrame(ohe.fit_transform(data[["gender"]]))

data_gender

Aplicando en la columna de la ciudad:

data_city = pd.DataFrame(ohe.fit_transform(data[["city"]]))

data_city

Aplicando en la columna de clase:

data_class = pd.DataFrame(ohe.fit_transform(data[["class"]]))

data_class

Esto se debe a que la columna de clase tiene 4 valores únicos.

Aplicando a la lista de variables categóricas:

data_cols = pd.DataFrame(ohe.fit_transform(data[cols]))

data_cols

Aquí, las primeras 2 columnas representan el género, las siguientes 4 columnas representan la clase y las 2 restantes representan la ciudad.

Codificación de etiquetas Scikit-learn

En la codificación de etiquetas, a cada categoría se le asigna un valor de 1 a N, donde N es el número de categorías para la función. No hay relación ni orden entre estas asignaciones.

from sklearn.preprocessing import LabelEncoder

le = LabelEncoder()
Label encoder takes no arguments
le_class = le.fit_transform(data[["class"]])

Comparando con la codificación one-hot

data_class

Codificación ordinal

Las variables codificadas de la codificación ordinal conservan la naturaleza ordinal (ordenada) de la variable. Se parece a la codificación de etiquetas, con la única diferencia de que la codificación de etiquetas no considera si una variable es ordinal o no; luego asignará una secuencia de enteros.

Ejemplo: la codificación ordinal asignará valores como Muy bueno (1) < Bueno (2) < Malo (3) < Peor (4)

Primero, necesitamos asignar el orden original de la variable a través de un diccionario.

temp = {'temperature' :['very cold', 'cold', 'warm', 'hot', 'very hot']}
df=pd.DataFrame(temp,columns=["temperature"])
temp_dict = {'very cold': 1,'cold': 2,'warm': 3,'hot': 4,"very hot":5}
df

Luego podemos mapear cada fila para la variable según el diccionario.

df["temp_ordinal"] = df.temperature.map(temp_dict)
df

Codificación de frecuencia

La categoría se asigna según la frecuencia de valores en su lote total.

data_freq = pd.DataFrame({'class' : ['A','B','C','D','A',"B","E","E","D","C","C","C","E","A","A"]})

Agrupación por columna de clase:

fe = data_freq.groupby("class").size()

Dividiendo por longitud:

fe_ = fe/len(data_freq)

Mapeo y redondeo:

data_freq["data_fe"] = data_freq["class"].map(fe_).round(2)
data_freq

En este artículo, vimos 5 tipos de esquemas de codificación. Del mismo modo, hay otros 10 tipos de codificación que no hemos analizado:

• Codificación Helmert
• Codificación media
• Codificación del peso de la evidencia
• Codificación de la razón de probabilidad
• Codificación hash
• Codificación de diferencia hacia atrás
• Dejar una codificación
• Codificación James-Stein
• Codificación del estimador M
• Codificador de termómetro

¿Qué método de codificación es el mejor?

No existe un método único que funcione mejor para cada problema o conjunto de datos. Personalmente, creo que el método get_dummies tiene la ventaja de que se puede implementar muy fácilmente.

Si desea leer acerca de los 15 tipos de codificación, aquí hay un muy buen artículo para consultar .

Aquí hay una hoja de trucos sobre cuándo usar qué tipo de codificación:

Fuente:  https://www.kdnuggets.com

#ml #machine-learning 

Lidar Com Dados Categóricos Para Aprendizado De Máquina

Confira este guia para implementar diferentes tipos de codificação para dados categóricos, incluindo uma folha de dicas sobre quando usar qual tipo.

Neste blog vamos explorar e implementar:

• Codificação One-Hot usando:
  • A biblioteca category_encoding do Python
  • Pré-processamento Scikit-learn
  • get_dummies dos pandas
• Codificação Binária
• Codificação de Frequência
• Codificação de Etiqueta
• Codificação Ordinal

O que são dados categóricos?

Os dados categóricos são um tipo de dados que são usados ​​para agrupar informações com características semelhantes, enquanto os dados numéricos são um tipo de dados que expressam informações na forma de números.

Exemplo de dados categóricos: sexo

Por que precisamos de codificação?

• A maioria dos algoritmos de aprendizado de máquina não pode lidar com variáveis ​​categóricas, a menos que as convertamos em valores numéricos
• O desempenho de muitos algoritmos varia até mesmo com base em como as variáveis ​​categóricas são codificadas

As variáveis ​​categóricas podem ser divididas em duas categorias:

• Nominal: nenhuma ordem específica
• Ordinal: há alguma ordem entre os valores

Também nos referiremos a uma folha de dicas que mostra quando usar qual tipo de codificação.

Método 1: usando a biblioteca do codificador de categoria do Python

category_encoders é uma incrível biblioteca Python que fornece 15 esquemas de codificação diferentes.

Aqui está a lista dos 15 tipos de codificação que a biblioteca suporta:

• Codificação One-Hot
• Codificação de Etiqueta
• Codificação Ordinal
• Codificação de Helmert
• Codificação Binária
• Codificação de Frequência
• Codificação Média
• Codificação de Peso de Evidência
• Codificação de Probabilidade
• Codificação de hash
• Codificação de diferença para trás
• Deixe uma codificação de fora
• Codificação James-Stein
• Codificação do estimador M
• Codificador de Termômetro

Importando bibliotecas:

import pandas as pd
import sklearn

pip install category_encoders

import category_encoders as ce

Criando um dataframe:

data = pd.DataFrame({ 'gender' : ['Male', 'Female', 'Male', 'Female', 'Female'],
                       'class' : ['A','B','C','D','A'],
                        'city' : ['Delhi','Gurugram','Delhi','Delhi','Gurugram'] })
data.head()

Implementando a codificação one-hot por meio do category_encoder

Neste método, cada categoria é mapeada para um vetor que contém 1 e 0 denotando a presença ou ausência do recurso. O número de vetores depende do número de categorias para recursos.

Crie um objeto do codificador one-hot:

ce_OHE = ce.OneHotEncoder(cols=['gender','city'])

data1 = ce_OHE.fit_transform(data)
data1.head()

Codificação Binária

A codificação binária converte uma categoria em dígitos binários. Cada dígito binário cria uma coluna de recurso.

ce_be = ce.BinaryEncoder(cols=['class']);

# transform the data
data_binary = ce_be.fit_transform(data["class"]);
data_binary

Da mesma forma, existem outros 14 tipos de codificação fornecidos por esta biblioteca.

Método 2: Usando os bonecos de pandas

pd.get_dummies(data,columns=["gender","city"])

Podemos atribuir um prefixo se quisermos, se não quisermos que a codificação use o padrão.

pd.get_dummies(data,prefix=["gen","city"],columns=["gender","city"])

Método 3: Usando o Scikit-learn

O Scikit-learn também possui 15 tipos diferentes de codificadores integrados, que podem ser acessados ​​em sklearn.preprocessing.

Codificação One-hot Scikit-learn

Vamos primeiro obter a lista de variáveis ​​categóricas de nossos dados:

s = (data.dtypes == 'object')
cols = list(s[s].index)

from sklearn.preprocessing import OneHotEncoder

ohe = OneHotEncoder(handle_unknown='ignore',sparse=False)

Aplicando na coluna de gênero:

data_gender = pd.DataFrame(ohe.fit_transform(data[["gender"]]))

data_gender

Aplicando na coluna da cidade:

data_city = pd.DataFrame(ohe.fit_transform(data[["city"]]))

data_city

Aplicando na coluna de classe:

data_class = pd.DataFrame(ohe.fit_transform(data[["class"]]))

data_class

Isso ocorre porque a coluna de classe tem 4 valores exclusivos.

Aplicando à lista de variáveis ​​categóricas:

data_cols = pd.DataFrame(ohe.fit_transform(data[cols]))

data_cols

Aqui, as 2 primeiras colunas representam o gênero, as 4 colunas seguintes representam a classe e as 2 restantes representam a cidade.

Codificação de rótulo Scikit-learn

Na codificação de rótulo, cada categoria recebe um valor de 1 a N, onde N é o número de categorias para o recurso. Não há relação ou ordem entre essas atribuições.

from sklearn.preprocessing import LabelEncoder

le = LabelEncoder()
Label encoder takes no arguments
le_class = le.fit_transform(data[["class"]])

Comparando com a codificação one-hot

data_class

Codificação Ordinal

As variáveis ​​codificadas da codificação ordinal mantêm a natureza ordinal (ordenada) da variável. Parece semelhante à codificação de rótulo, a única diferença é que a codificação de rótulo não considera se uma variável é ordinal ou não; ele então atribuirá uma sequência de inteiros.

Exemplo: A codificação ordinal atribuirá valores como Muito Bom(1) < Bom(2) < Ruim(3) < Pior(4)

Primeiro, precisamos atribuir a ordem original da variável por meio de um dicionário.

temp = {'temperature' :['very cold', 'cold', 'warm', 'hot', 'very hot']}
df=pd.DataFrame(temp,columns=["temperature"])
temp_dict = {'very cold': 1,'cold': 2,'warm': 3,'hot': 4,"very hot":5}
df

Em seguida, podemos mapear cada linha para a variável de acordo com o dicionário.

df["temp_ordinal"] = df.temperature.map(temp_dict)
df

Codificação de Frequência

A categoria é atribuída conforme a frequência de valores em seu lote total.

data_freq = pd.DataFrame({'class' : ['A','B','C','D','A',"B","E","E","D","C","C","C","E","A","A"]})

Agrupando por coluna de classe:

fe = data_freq.groupby("class").size()

Dividindo por comprimento:

fe_ = fe/len(data_freq)

Mapeamento e arredondamento:

data_freq["data_fe"] = data_freq["class"].map(fe_).round(2)
data_freq

Neste artigo, vimos 5 tipos de esquemas de codificação. Da mesma forma, existem 10 outros tipos de codificação que não analisamos:

• Codificação de Helmert
• Codificação Média
• Codificação de Peso de Evidência
• Codificação de Probabilidade
• Codificação de hash
• Codificação de diferença para trás
• Deixe uma codificação de fora
• Codificação James-Stein
• Codificação do estimador M
• Codificador de Termômetro

Qual método de codificação é melhor?

Não existe um método único que funcione melhor para cada problema ou conjunto de dados. Pessoalmente, acho que o método get_dummies tem uma vantagem em sua capacidade de ser implementado com muita facilidade.

Se você quiser ler sobre todos os 15 tipos de codificação, aqui está um artigo muito bom para consultar .

Aqui está uma folha de dicas sobre quando usar que tipo de codificação:

Fonte:  https://www.kdnuggets.com

#ml #machine-learning 

Is Domain Knowledge Important for Machine Learning?

Developing machine learning models involves a lot of steps. Whether you’re working with labeled or unlabeled data, you might think numbers are just numbers, and it doesn’t matter what each of the features of a dataset signifies when it comes to spitting out insights with the potential for true impact.

Source: https://www.kdnuggets.com

#machine-learning #ml 

Kiến Thức Miền Có Quan Trọng Đối Với Học Máy Không?

Việc phát triển các mô hình học máy bao gồm rất nhiều bước. Cho dù bạn đang làm việc với dữ liệu được gắn nhãn hay không được gắn nhãn, bạn có thể nghĩ rằng các con số chỉ là những con số và không quan trọng mỗi tính năng của tập dữ liệu biểu thị điều gì khi nói đến việc đưa ra những thông tin chi tiết có tiềm năng tác động thực sự. Đúng là có rất nhiều thư viện học máy tuyệt vời như scikit-learning, giúp thu thập một số dữ liệu và đưa chúng vào một mô hình cắt cookie dễ dàng hơn. Khá nhanh chóng, bạn có thể bắt đầu nghĩ rằng không có vấn đề gì bạn không thể giải quyết bằng học máy.

Thành thật mà nói, đó là suy nghĩ của người mới bắt đầu. Bạn vẫn chưa nhận thức được mọi thứ bạn chưa biết. Các tập dữ liệu được cung cấp trong các khóa học máy học hoặc những tập miễn phí bạn tìm thấy trực tuyến thường đã được chuẩn bị kỹ lưỡng và thuận tiện để sử dụng khi áp dụng mô hình học máy, nhưng một khi bạn đưa kỹ năng và kiến ​​thức của mình ra khỏi play-pen và bước vào thế giới thực, bạn sẽ phải đối mặt với một số thách thức bổ sung.

Nhiều người tin rằng kiến ​​thức miền hoặc kiến ​​thức bổ sung về ngành hoặc lĩnh vực mà dữ liệu liên quan là không cần thiết. Và đó là sự thật. Bạn có CẦN kiến ​​thức miền trong lĩnh vực bạn đang phát triển mô hình không? Không. Bạn vẫn có thể tạo ra các mô hình khá chính xác mà không có nó. Về mặt lý thuyết, học sâu và học máy là các phương pháp tiếp cận hộp đen. Điều này có nghĩa là bạn có thể đưa dữ liệu được gắn nhãn vào một mô hình mà không cần kiến ​​thức sâu về lĩnh vực này và thậm chí không cần xem xét dữ liệu rất kỹ.

Tuy nhiên, nếu bạn đi theo con đường này, bạn sẽ phải đối mặt với hậu quả. Đây là một cách rất kém hiệu quả để đào tạo các bộ phân loại và để hoạt động tốt, bạn sẽ cần một lượng lớn các tập dữ liệu được gắn nhãn và rất nhiều sức mạnh tính toán để tạo ra các mô hình chính xác.

Nếu bạn kết hợp kiến ​​thức miền vào kiến ​​trúc và mô hình của mình, bạn có thể giải thích kết quả dễ dàng hơn rất nhiều, cho cả bản thân bạn và người xem bên ngoài. Mỗi chút kiến ​​thức miền có thể đóng vai trò như một bước đệm thông qua hộp đen của mô hình học máy.

Rất dễ dàng nghĩ rằng kiến ​​thức miền là không cần thiết vì đối với nhiều bộ dữ liệu hiển thị như COCO, kiến ​​thức miền hạn chế được yêu cầu là một phần của việc trở thành con người nhìn thấy. Ngay cả những bộ dữ liệu phức tạp hơn có chứa các tế bào ung thư cũng hiển nhiên tương tự đối với mắt người, mặc dù thiếu kiến ​​thức ở cấp độ chuyên gia. Bạn có thể đánh giá cơ bản về sự giống hoặc khác nhau giữa các tế bào mà không cần bất kỳ kiến ​​thức y khoa cụ thể nào.

Xử lý ngôn ngữ tự nhiên (NLP) và thị giác máy tính là những ví dụ điển hình về các lĩnh vực mà chúng ta dễ dàng nghĩ rằng kiến ​​thức miền là hoàn toàn không cần thiết, nhưng hơn thế nữa, vì chúng là những nhiệm vụ bình thường đối với chúng tôi, chúng tôi thậm chí có thể không nhận thấy cách chúng tôi áp dụng miền của mình hiểu biết.

Nếu bạn bắt đầu làm việc trong các lĩnh vực như phát hiện ngoại lệ, đây không phải là nhiệm vụ hàng ngày của con người, thì tầm quan trọng của kiến ​​thức miền sẽ nhanh chóng trở nên rõ ràng.

Kiến thức miền để xử lý trước dữ liệu

Hãy cùng tìm hiểu cách tận dụng kiến ​​thức miền trong bước xử lý trước dữ liệu của chu trình phát triển mô hình học máy.

Trong một tập dữ liệu, không phải mọi điểm dữ liệu đều có cùng giá trị. Nếu bạn thu thập 100 mẫu mới giống hệt nhau, chúng không giúp mẫu tìm hiểu thêm bất kỳ thông tin nào. Họ thực sự có thể tập trung mô hình theo một hướng cụ thể mà không quan trọng.

Nếu bạn đang xem 100 bức ảnh về ô dù và bạn biết rằng mô hình này được dùng để phân loại tất cả các loại phụ kiện, thì rõ ràng là tập dữ liệu mẫu của bạn không đại diện cho toàn bộ dân số. Nếu không có kiến ​​thức về miền, có thể rất khó để biết điểm dữ liệu nào thêm giá trị hoặc nếu chúng đã được biểu diễn trong tập dữ liệu.

Nếu bạn đang làm việc trong một lĩnh vực không dễ dàng tiếp cận với kiến ​​thức chung hiện có của bạn, bạn có thể xây dựng thành kiến ​​thông qua dữ liệu đào tạo, điều này có thể làm ảnh hưởng đến độ chính xác và độ chắc chắn của mô hình của bạn.

Một cách khác mà kiến ​​thức miền có thể đóng góp một cú đấm trong bước xử lý trước dữ liệu là xác định tầm quan trọng của tính năng. Nếu bạn hiểu rõ tầm quan trọng của từng tính năng, bạn có thể phát triển các chiến lược tốt hơn để xử lý dữ liệu cho phù hợp. Điều thực sự quan trọng là phải hiểu các tính năng thực tế là gì để làm như vậy. Điều này có ảnh hưởng lớn đến cách bạn xử lý các tính năng trong tương lai.

Kiến thức miền để chọn đúng mô hình

Có nhiều mô hình học máy khác nhau và một số có thể phù hợp hơn những mô hình khác do nhiều yếu tố. Dữ liệu được gắn nhãn hay không được gắn nhãn? Bạn có bao nhiêu dữ liệu? Các loại dữ liệu là các đối tượng địa lý? Các kiểu dữ liệu của các đối tượng địa lý có đồng nhất không? Đầu ra mục tiêu của bạn là giá trị liên tục hay phân loại? Chọn đúng mô hình là quan trọng, nhưng rất hiếm khi có thể áp dụng mô hình đã chọn của bạn trực tiếp mà không cần điều chỉnh nó. Ví dụ, các khu rừng ngẫu nhiên có thể xử lý các kiểu dữ liệu không đồng nhất ngay lập tức.

Việc lựa chọn mô hình phù hợp đòi hỏi kiến ​​thức chuyên sâu về máy học, nhưng có rất nhiều tài nguyên sẵn có để giúp bạn lựa chọn nếu bạn không phải là một chuyên gia về máy học. Tôi đã tập hợp ba phần mềm hàng đầu của mình từ các bảng gian lận học máy từ Towards Data Science, datacamp và Microsoft.

Kiến thức miền để điều chỉnh mô hình và kiến ​​trúc

Kiến thức miền cho phép bạn điều chỉnh mô hình tốt hơn để phù hợp với tình hình. Việc tối ưu hóa toán học chỉ tiến xa đến mức này, và thường để có được những bước tiến lớn trong cải tiến, điều quan trọng là phải có kiến ​​thức miền đáng kể trong lĩnh vực này.

Một cách quan trọng để áp dụng kiến ​​thức miền của bạn nhằm thúc đẩy cải thiện độ chính xác và mạnh mẽ của mô hình của bạn là kết hợp kiến ​​thức miền vào kiến ​​trúc của mô hình bạn đang phát triển.

Như tôi đã đề cập trước đây, xử lý ngôn ngữ tự nhiên là một trong những lĩnh vực của học máy, giúp làm rõ kiến ​​thức miền có thể hữu ích như thế nào. Hãy nói về cách nhúng từ và sự chú ý để cho thấy việc nói tiếng người là một trợ giúp lớn như thế nào, nhưng suy nghĩ như một nhà ngôn ngữ học thực sự có thể nâng cao hiệu suất của mô hình xử lý ngôn ngữ tự nhiên.

Kiến thức miền để xử lý ngôn ngữ tự nhiên

Kiến thức miền đã được áp dụng cho tất cả các ứng dụng của học máy. Những điều chỉnh nhỏ đã được thực hiện trong vài thập kỷ qua để áp dụng tốt hơn các mô hình học máy trong nhiều lĩnh vực. Kiến thức miền chắc chắn đã được áp dụng cho các mô hình được sử dụng trong xử lý ngôn ngữ tự nhiên. Hãy cùng xem qua một vài ví dụ về cách thức những sự phát triển này ra đời.

Nhúng từ

Nếu bạn nghĩ về các con số và từ ngữ, có một sự khác biệt khá lớn trong cách chúng ta nghĩ về chúng. Nếu bạn có chiều cao của tất cả mọi người trong một nhóm, bạn có thể dễ dàng tìm ra một số thống kê liên quan đến trung vị, ngoại lệ, v.v., tất cả đều dựa trên chiều cao. Nếu mọi người trong nhóm cho bạn một từ để thể hiện cảm giác của họ hôm nay, bạn sẽ chuyển từ đó thành bất kỳ loại tổng hợp có ý nghĩa nào?

Bạn nên xem xét những gì bạn có thể làm để tạo ra một biểu diễn kỹ thuật số của một từ. Bạn có nên chỉ sử dụng các chữ cái? Điều đó có ý nghĩa? Là một người nói ngôn ngữ, chúng ta ngay lập tức có ý nghĩa đằng sau từ. Chúng tôi không lưu trữ các từ bằng các chữ cái của họ. Hãy nghĩ về một cái cây. Bạn đã hình dung ra một cái cây hay tâm trí của bạn hướng về cái cây? Lưu trữ đại diện của một từ dưới dạng các chữ cái không thực sự mang lại cho chúng ta bất kỳ lợi thế nào khi hiểu ý nghĩa hoặc tầm quan trọng.

Nhúng từ là “một kiểu biểu diễn từ cho phép các từ có nghĩa tương tự có một biểu diễn [số] tương tự”. Các biểu diễn số được học bằng cách sử dụng các mô hình học tập không giám sát.

Các biểu diễn số này là các vectơ biểu thị cách một từ được sử dụng. Biểu diễn số này đi xa đến mức cho phép bạn sử dụng khoảng cách Euclide giữa các biểu diễn hai từ để định lượng cách hai từ tương tự được sử dụng trong văn bản đào tạo.

Các vectơ cho “Adidas” và “Nike” có thể khá giống nhau. Chính xác những gì mà mỗi trường của vectơ đại diện chắc chắn là không rõ ràng vì chúng được phát triển bằng cách sử dụng phương pháp học không giám sát, nhưng có nghĩa là một từ đại diện cho một khái niệm tương tự có cách biểu diễn tương tự theo như mô hình hiểu.

Hãy xem bài đăng “Học tập có giám sát và không giám sát” của chúng tôi nếu bạn muốn biết học tập có giám sát và không giám sát thực sự là gì và các thuật toán sử dụng các phương pháp học tập này.

Chú ý

Chú ý là một khái niệm rất có giá trị và hữu ích. Sự chú ý đã được đưa vào xử lý ngôn ngữ tự nhiên và nhận dạng hình ảnh trong thế giới của các mô hình học máy vì một lý do rất chính đáng.

Xử lý ngôn ngữ tự nhiên để dịch đã là một mô hình học sâu từ đầu những năm 2000. Khoảng năm 2013, trí nhớ ngắn hạn dài (LSTM) ra mắt trong lĩnh vực này và thống trị trong một vài năm. Một mô hình LTSM đọc câu, tạo một biểu diễn ẩn và sau đó sử dụng biểu diễn ẩn để tạo ra câu đầu ra.

Là con người, nếu chúng ta dịch, chúng ta không chỉ đọc câu và phun ra bản dịch. Chúng ta có xu hướng xem lại toàn bộ câu hoặc chúng ta sẽ tập trung vào một số phần nhất định khi chúng ta muốn xem lại ngữ cảnh của từ đích.

Ví dụ từ "đọc". Nó đại diện cho thì hiện tại hay quá khứ? Bạn tập trung vào những phần nào khác của câu để xác định điều đó? Bạn có cần thông tin từ các câu xung quanh không? “Tôi đọc sách mỗi năm” có nghĩa là riêng một điều, nhưng nếu tôi muốn nói, “Tôi đã làm nhiều thứ trước khi vào đại học. Tôi đọc sách mỗi năm. Tôi đã ăn tối với bố mẹ tôi mỗi ngày, ”câu này mang một ý nghĩa khác và“ đọc ”đại diện cho một hành động diễn ra ở hiện tại trong ví dụ đầu tiên và trong quá khứ trong ví dụ thứ hai.

Sự chú ý xây dựng các mối quan hệ này giữa các từ khác nhau trong câu hoặc các câu. Đối với mỗi từ chúng ta muốn dịch, nó đánh dấu các từ khác nhau trong câu gốc theo mức độ quan trọng của những từ liên kết này với từ đích. Một người nào đó không phải là một dịch giả có kinh nghiệm hoặc chuyên nghiệp có thể chỉ dịch từng từ một và trong khi thông tin chung vẫn được truyền đạt, việc tính đến tầm quan trọng của các từ liên quan khi dịch từ mục tiêu sẽ tạo ra bản dịch chính xác hơn nhiều. Sự chú ý cho phép chúng tôi xây dựng mô hình dịch chuyên nghiệp đó thành kiến ​​trúc của mô hình học sâu.

Tại sao Kiến thức miền lại quan trọng đối với Học máy

Nếu không có kiến ​​thức về miền, bạn có thể chọn tất cả các hộp tạo ra một mô hình có thể chấp nhận được, trong đó có một số con số. Với kiến ​​thức về miền, bạn sẽ biết dữ liệu nào là tốt nhất để sử dụng để đào tạo và kiểm tra mô hình của mình. Bạn cũng sẽ nhận ra cách bạn có thể điều chỉnh mô hình bạn sử dụng để thể hiện tốt hơn tập dữ liệu và vấn đề bạn đang cố gắng giải quyết cũng như cách tận dụng tốt nhất những thông tin chi tiết mà mô hình của bạn tạo ra.

Máy học là một hộp công cụ. Nếu bạn kéo một chiếc cưa điện ra, có thể bạn sẽ cưa được một ít gỗ, nhưng có thể bạn sẽ không thể đóng một loạt tủ nếu không có kiến ​​thức chuyên môn của một người thợ mộc. Kiến thức miền sẽ cho phép bạn đưa tác động của các kỹ năng học máy của mình lên một mức độ quan trọng cao hơn nhiều.

Nguồn:  https://www.kdnuggets.com

#machine-learning #ml 

Важны ли знания предметной области для машинного обучения?

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

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

Многие люди считают, что знание предметной области или дополнительные знания об отрасли или области, к которой относятся данные, излишни. И это правда. Вам НУЖНЫ знания предметной области в той области, в которой вы разрабатываете модель? Нет. Вы все еще можете создавать довольно точные модели без него. Теоретически глубокое и машинное обучение — это подходы черного ящика. Это означает, что вы можете поместить размеченные данные в модель без глубоких знаний области и даже без внимательного изучения данных.

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

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

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

Обработка естественного языка (NLP) и компьютерное зрение являются яркими примерами областей, в которых легко думать, что знание предметной области совершенно не нужно, но тем более, что это такие обычные для нас задачи, что мы можем даже не заметить, как мы применяем нашу предметную область. знания.

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

Знание предметной области для предварительной обработки данных

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

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

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

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

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

Знание предметной области для выбора правильной модели

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

Выбор правильной модели требует глубоких знаний в области машинного обучения, но существует множество ресурсов, которые помогут вам сделать свой выбор, если вы не являетесь экспертом в области машинного обучения. Я собрал тройку лучших из шпаргалок по машинному обучению от Towards Data Science, datacamp и Microsoft.

Знание предметной области для настройки модели и архитектуры

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

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

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

Знание предметной области для обработки естественного языка

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

Вложения слов

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

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

Встраивание слов — это «тип представления слов, который позволяет словам с похожим значением иметь аналогичное [числовое] представление». Числовые представления изучаются с использованием моделей обучения без учителя.

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

Векторы для «Adidas» и «Nike», вероятно, будут очень похожими. Что именно представляет каждое поле вектора, конечно, неясно, поскольку они разработаны с использованием обучения без учителя, но имеет смысл, что слово, представляющее подобное понятие, имеет аналогичное представление, насколько модель понимает.

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

Внимание

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

Обработка естественного языка для перевода была моделью глубокого обучения с начала 2000-х годов. Примерно в 2013 году долговременная кратковременная память (LSTM) дебютировала в этой области и доминировала в течение нескольких лет. Модель LTSM считывает предложение, создает скрытое представление, а затем использует скрытое представление для создания выходного предложения.

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

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

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

Почему знание предметной области имеет решающее значение для машинного обучения

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

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

Источник:  https://www.kdnuggets.com

#ml #machine-learning 

領域知識對機器學習重要嗎？

開發機器學習模型涉及很多步驟。無論您使用的是標記數據還是未標記數據，您都可能認為數字只是數字，當涉及到產生具有真正影響潛力的見解時，數據集的每個特徵所代表的意義並不重要。確實有很多很棒的機器學習庫，比如 scikit-learn，它們可以很容易地收集一些數據並將它們放入千篇一律的模型中。很快，您可能會開始認為沒有任何問題是機器學習無法解決的。

坦率地說，這是初學者的心態。你還沒有意識到你不知道的一切。機器學習課程中提供的數據集或您在網上找到的免費數據集通常已經經過修飾，並且在應用機器學習模型時使用起來很方便，但是一旦您將技能和知識從遊戲筆中帶入現實世界，您將面臨一些額外的挑戰。

許多人認為，領域知識或有關數據所屬行業或領域的額外知識是多餘的。這是真的。您需要開發模型領域的領域知識嗎？不。沒有它，您仍然可以生成相當準確的模型。從理論上講，深度學習和機器學習是黑盒方法。這意味著您可以將標記的數據放入模型中，而無需深入了解該領域，甚至無需非常仔細地查看數據。

但是，如果你走這條路，你將不得不處理後果。這是訓練分類器的一種非常低效的方法，並且為了正常運行，您需要大量標記的數據集和大量的計算能力才能生成準確的模型。

如果您將領域知識整合到您的架構和模型中，則可以更輕鬆地向您自己和外部查看者解釋結果。每一點領域知識都可以作為機器學習模型黑匣子的墊腳石。

很容易認為不需要領域知識，因為對於像 COCO 這樣的許多可見數據集，所需的有限領域知識是作為一個有洞察力的人的一部分。儘管缺乏專家級知識，但包含癌細胞的更複雜的數據集對人眼來說同樣顯而易見。您可以在沒有任何特定醫學知識的情況下對細胞之間的相似性或差異進行基本評估。

自然語言處理 (NLP) 和計算機視覺是很容易認為領域知識完全沒有必要的領域的主要例子，但更重要的是，因為它們對我們來說是如此正常的任務，我們甚至可能沒有註意到我們是如何應用我們的領域的知識。

如果您開始在異常值檢測等領域工作，這不是日常的人工任務，領域知識的重要性很快就會變得顯而易見。

數據預處理領域知識

讓我們深入研究如何在機器學習模型開發週期的數據預處理步驟中利用領域知識。

在數據集中，並非每個數據點都具有相同的值。如果您收集 100 個相同的新樣本，它們不會幫助模型學習任何額外的信息。他們實際上可能將模型集中在一個不重要的特定方向上。

如果您正在查看 100 張雨傘圖片，並且您知道該模型應該對各種配件進行分類，那麼您的樣本數據集顯然不能代表整個人群。如果沒有領域知識，很難知道哪些數據點增加了價值，或者它們是否已經在數據集中表示。

如果您在一個不太容易適應現有常識的領域工作，您可以通過訓練數據建立偏差，這可能會損害模型的準確性和穩健性。

領域知識可以在數據預處理步驟中發揮作用的另一種方式是確定特徵重要性。如果您對每個功能的重要性有很好的認識，您可以製定更好的策略來相應地處理數據。為了做到這一點，了解實際功能是非常重要的。這對您如何處理未來的功能有很大的影響。

選擇正確模型的領域知識

有許多不同的機器學習模型，考慮到許多因素，有些模型可能比其他模型更合適。數據是標記的還是未標記的？你有多少數據？有哪些數據類型的特徵？特徵的數據類型是同質的嗎？您的目標輸出是連​​續值還是分類？選擇正確的模型很重要，但很少能直接應用您選擇的模型而不對其進行調整。例如，隨機森林可以開箱即用地處理異構數據類型。

選擇正確的模型需要深入的機器學習知識，但如果您不是機器學習專家，有很多資源可以幫助您做出選擇。我從 Towards Data Science、datacamp 和 Microsoft 的機器學習備忘單中收集了我的前三名。

調整模型和架構的領域知識

領域知識使您可以更好地調整模型以適應情況。數學優化只到此為止，並且通常要在改進方面取得巨大進步，在該領域擁有相當多的領域知識至關重要。

應用您的領域知識來提高模型的準確性和穩健性的一個重要方法是將領域知識合併到您正在開發的模型的架構中。

正如我之前提到的，自然語言處理是機器學習的領域之一，它清楚地說明了領域知識如何發揮作用。讓我們談談詞嵌入和注意力，以展示說人類語言如何有很大幫助，但像語言學家一樣思考可以真正提升自然語言處理模型的性能。

自然語言處理領域知識

領域知識已應用於機器學習的所有應用。在過去的幾十年裡，為了更好地在許多領域應用機器學習模型，我們進行了一些小的調整。領域知識肯定已應用於自然語言處理中使用的模型。讓我們通過幾個例子來了解這些發展是如何產生的。

詞嵌入

如果你考慮數字和單詞，我們對它們的看法會有很大的不同。如果你有一個組中每個人的身高，你可以很容易地根據身高吐出一些關於中位數、異常值等的統計數據。如果小組中的每個人都給你一個詞來代表他們今天的感受，你將如何將其轉換為任何有意義的聚合？

您應該考慮如何創建單詞的數字表示。你應該只使用字母嗎？那有意義嗎？作為一個會說這種語言的人，我們立刻就能明白這個詞背後的含義。我們不通過字母來存儲單詞。想想一棵樹。你是在想像一棵樹還是你的思緒轉向了樹？在理解含義或意義時，將單詞的表示存儲為字母並沒有真正給我們帶來任何好處。

詞嵌入是“一種詞表示，它允許具有相似含義的詞具有相似的 [數字] 表示”。數值表示是使用無監督學習模型來學習的。

這些數字表示是表示單詞如何使用的向量。這種數字表示甚至允許您使用兩個單詞表示之間的歐幾里德距離來量化訓練文本中使用的兩個單詞的相似程度。

“阿迪達斯”和“耐克”的向量可能非常相似。向量的每個字段究竟代表什麼當然不清楚，因為它們是使用無監督學習開發的，但就模型理解而言，代表相似概念的單詞具有相似的表示是有道理的。

如果您想了解監督和無監督學習到底是什麼以及使用這些學習方法的算法，請查看我們的文章“監督與無監督學習”。

注意力

注意力是一個非常有價值和有用的概念。注意力已經進入機器學習模型領域的自然語言處理和圖像識別領域，這是有充分理由的。

自 2000 年代初以來，用於翻譯的自然語言處理一直是一種深度學習模型。2013 年左右，長短期記憶（LSTM）在該領域首次亮相並統治了幾年。LTSM 模型讀取句子，創建隱藏表示，然後使用隱藏表示生成輸出句子。

作為人類，如果我們翻譯，我們不只是閱讀句子並吐出翻譯。我們傾向於一遍又一遍地查看整個句子，或者當我們想要重新審視目標詞的上下文時，我們會專注於某些部分。

例如“閱讀”這個詞。它代表現在時還是過去時？您關注句子的其他哪些部分來確定這一點？你需要來自周圍句子的信息嗎？“我每年都讀書”本身就意味著一件事，但如果我說，“我在上大學之前做了很多事情。我每年都看書。我每天和父母一起吃晚飯，”這句話具有不同的含義，“閱讀”代表第一個例子中發生在現在和第二個例子中的過去發生的動作。

注意力在一個或多個句子中的不同單詞之間建立這些關係。對於我們要翻譯的每個單詞，它會根據這些關聯單詞與目標單詞的重要性來突出顯示原始句子中的不同單詞。不是經驗豐富或專業翻譯的人可能只是逐字翻譯，雖然仍會傳達一般信息，但在翻譯目標詞時考慮相關詞的重要性將產生更準確的翻譯。注意力使我們能夠將這種專業的翻譯模式構建到深度學習模型的架構中。

為什麼領域知識對機器學習至關重要

如果沒有領域知識，您可以檢查生成可接受模型的所有框，該模型會吐出一些數字。借助領域知識，您將知道最適合使用哪些數據來訓練和測試您的模型。您還將了解如何定制您使用的模型以更好地表示數據集和您嘗試解決的問題，以及如何充分利用您的模型產生的洞察力。

機器學習是一個工具箱。如果您拉出電鋸，您可能會設法切割一些木材，但如果沒有木匠的專業知識，您可能無法建造一堆櫥櫃。領域知識將使您能夠將機器學習技能的影響提升到更高的重要性。

來源：  https ://www.kdnuggets.com

#ml #machine-learning 

Connaissance Du Domaine Pour L'apprentissage Automatique

Le développement de modèles d'apprentissage automatique implique de nombreuses étapes. Que vous travailliez avec des données étiquetées ou non étiquetées, vous pourriez penser que les chiffres ne sont que des chiffres, et peu importe ce que signifie chacune des caractéristiques d'un ensemble de données lorsqu'il s'agit de cracher des informations avec un potentiel d'impact réel. Il est vrai qu'il existe des tonnes d'excellentes bibliothèques d'apprentissage automatique, telles que scikit-learn, qui facilitent la collecte de données et les placent dans un modèle à l'emporte-pièce. Assez rapidement, vous pourriez commencer à penser qu'il n'y a pas de problème que vous ne pouvez pas résoudre avec l'apprentissage automatique.

Franchement, c'est l'état d'esprit d'un débutant. Vous n'êtes pas encore conscient de tout ce que vous ne savez pas. Les ensembles de données fournis dans les cours d'apprentissage automatique ou ceux gratuits que vous trouvez en ligne ont souvent déjà été préparés et sont pratiques à utiliser lors de l'application de modèles d'apprentissage automatique, mais une fois que vous avez sorti vos compétences et vos connaissances du parc de jeu et dans le monde réel, vous 'll faire face à des défis supplémentaires.

Beaucoup de gens pensent que la connaissance du domaine ou des connaissances supplémentaires concernant l'industrie ou le domaine auquel les données se rapportent sont superflues. Et c'est un peu vrai. Avez-vous BESOIN de connaissances dans le domaine dans lequel vous développez le modèle ? Non. Vous pouvez toujours produire des modèles assez précis sans cela. Théoriquement, l'apprentissage profond et l'apprentissage automatique sont des approches de type boîte noire. Cela signifie que vous pouvez mettre des données étiquetées dans un modèle sans connaissance approfondie de la zone et sans même regarder les données de très près.

Mais, si vous empruntez cette voie, vous devrez faire face aux conséquences. C'est un moyen très inefficace de former des classificateurs, et pour fonctionner correctement, vous aurez besoin d'énormes quantités d'ensembles de données étiquetés et d'une grande puissance de calcul afin de produire des modèles précis.

Si vous intégrez la connaissance du domaine dans votre architecture et votre modèle, il peut être beaucoup plus facile d'expliquer les résultats, à vous-même et à un spectateur extérieur. Chaque élément de connaissance du domaine peut servir de tremplin à travers la boîte noire d'un modèle d'apprentissage automatique.

Il est très facile de penser que la connaissance du domaine n'est pas nécessaire, car pour de nombreux ensembles de données visibles comme COCO, la connaissance limitée du domaine requise fait partie du fait d'être un être humain voyant. Des ensembles de données encore plus complexes contenant des cellules cancéreuses sont tout aussi évidents pour l'œil humain, malgré un manque de connaissances de niveau expert. Vous pouvez faire une évaluation de base de la similitude ou des différences entre les cellules sans aucune connaissance médicale spécifique.

Le traitement du langage naturel (NLP) et la vision par ordinateur sont d'excellents exemples de domaines où il est facile de penser que la connaissance du domaine est totalement inutile, mais plus encore parce qu'il s'agit de tâches si normales pour nous, nous ne remarquons peut-être même pas comment nous appliquons notre domaine. connaissances.

Si vous commencez à travailler dans des domaines tels que la détection des valeurs aberrantes, qui n'est pas une tâche humaine quotidienne, l'importance de la connaissance du domaine devient rapidement évidente.

Connaissance du domaine pour le prétraitement des données

Examinons comment la connaissance du domaine peut être exploitée dans l'étape de prétraitement des données du cycle de développement du modèle d'apprentissage automatique.

Dans un ensemble de données, tous les points de données n'ont pas la même valeur. Si vous collectez 100 nouveaux échantillons identiques, ils n'aident pas le modèle à apprendre des informations supplémentaires. Ils pourraient en fait concentrer le modèle dans une direction spécifique qui n'est pas importante.

Si vous regardez 100 images de parapluies et que vous savez que ce modèle est censé classer toutes sortes d'accessoires, il est clair que votre échantillon de données n'est pas représentatif de l'ensemble de la population. Sans connaissance du domaine, il peut être très difficile de savoir quels points de données ajoutent de la valeur ou s'ils sont déjà représentés dans l'ensemble de données.

Si vous travaillez dans un domaine qui ne se prête pas si facilement à vos connaissances générales existantes, vous pouvez créer des biais via les données de formation, ce qui peut nuire à la précision et à la robustesse de votre modèle.

Une autre façon dont la connaissance du domaine peut donner un coup de pouce à l'étape de prétraitement des données consiste à déterminer l'importance des fonctionnalités. Si vous avez une bonne idée de l'importance de chaque fonctionnalité, vous pouvez développer de meilleures stratégies pour traiter les données en conséquence. Il est vraiment important de comprendre quelles sont les fonctionnalités réelles pour le faire. Cela a une grande influence sur la façon dont vous gérez les fonctionnalités à l'avenir.

Connaissance du domaine pour choisir le bon modèle

Il existe de nombreux modèles d'apprentissage automatique différents, et certains peuvent être plus appropriés que d'autres compte tenu de nombreux facteurs. Les données sont-elles étiquetées ou non ? Combien de données avez-vous ? De quel type de types de données s'agit-il ? Les types de données des entités sont-ils homogènes ? Votre résultat cible est-il une valeur continue ou une classification ? Choisir le bon modèle est important, mais il est très rare de pouvoir appliquer directement votre modèle sélectionné sans y apporter de modifications. Les forêts aléatoires, par exemple, peuvent gérer des types de données hétérogènes dès le départ.

La sélection du bon modèle nécessite des connaissances approfondies en apprentissage automatique, mais il existe de nombreuses ressources pour vous aider à faire votre choix si vous n'êtes pas un expert en apprentissage automatique. J'ai rassemblé mon top trois à partir de feuilles de triche d'apprentissage automatique de Towards Data Science, datacamp et Microsoft.

Connaissance du domaine pour ajuster le modèle et l'architecture

La connaissance du domaine vous permet de mieux ajuster le modèle à la situation. Les optimisations mathématiques ne vont pas très loin, et souvent pour obtenir de grands sauts d'amélioration, il est crucial d'avoir une connaissance considérable du domaine dans le domaine.

Un moyen significatif d'appliquer vos connaissances du domaine pour améliorer la précision et la robustesse de votre modèle consiste à intégrer les connaissances du domaine dans l'architecture du modèle que vous développez.

Comme je l'ai déjà mentionné, le traitement du langage naturel est l'un des domaines de l'apprentissage automatique, ce qui montre clairement à quel point la connaissance du domaine peut être utile. Parlons des incorporations de mots et de l'attention pour montrer à quel point parler une langue humaine est d'une grande aide, mais penser comme un linguiste peut vraiment améliorer les performances d'un modèle de traitement du langage naturel.

Connaissance du domaine pour le traitement du langage naturel

La connaissance du domaine a été appliquée à toutes les applications de l'apprentissage automatique. De petits ajustements ont été apportés au cours des dernières décennies pour mieux appliquer les modèles d'apprentissage automatique dans de nombreux domaines. La connaissance du domaine a certainement été appliquée aux modèles utilisés dans le traitement du langage naturel. Passons en revue quelques exemples de la façon dont ces développements se sont produits.

Incorporations de mots

Si vous pensez aux nombres et aux mots, il y a une assez grande différence dans la façon dont nous les considérons. Si vous avez les tailles de tout le monde dans un groupe, vous pouvez facilement cracher des statistiques concernant la médiane, les valeurs aberrantes, etc., toutes basées sur la taille. Si tout le monde dans le groupe vous donnait un mot pour représenter ce qu'il ressent aujourd'hui, comment le convertiriez-vous en un agrégat significatif ?

Vous devriez réfléchir à ce que vous pouvez faire pour créer une représentation numérique d'un mot. Faut-il utiliser uniquement des lettres ? Cela a-t-il du sens? En tant que personne qui parle la langue, nous avons immédiatement le sens derrière le mot. Nous ne stockons pas les mots par leurs lettres. Pensez à un arbre. Avez-vous imaginé un arbre ou votre esprit est-il allé à l'arbre ? Stocker la représentation d'un mot sous forme de lettres ne nous apporte pas vraiment d'avantage lorsqu'il s'agit de comprendre le sens ou la signification.

Les incorporations de mots sont "un type de représentation de mots qui permet à des mots ayant une signification similaire d'avoir une représentation [numérique] similaire". Les représentations numériques sont apprises à l'aide de modèles d'apprentissage non supervisés.

Ces représentations numériques sont des vecteurs qui représentent la façon dont un mot est utilisé. Cette représentation numérique va jusqu'à vous permettre d'utiliser la distance euclidienne entre les représentations de deux mots pour quantifier la façon dont deux mots similaires sont utilisés dans le texte d'entraînement.

Les vecteurs pour "Adidas" et "Nike" seraient probablement assez similaires. Ce que représente exactement chaque champ du vecteur n'est certainement pas clair car ils sont développés à l'aide d'un apprentissage non supervisé, mais il est logique qu'un mot qui représente un concept similaire ait une représentation similaire dans la mesure où le modèle comprend.

Consultez notre article "Apprentissage supervisé vs non supervisé" si vous voulez savoir ce qu'est réellement l'apprentissage supervisé et non supervisé et les algorithmes qui utilisent ces approches d'apprentissage.

Attention

L'attention est un concept très précieux et utile. L'attention s'est portée sur le traitement du langage naturel et la reconnaissance d'images dans le monde des modèles d'apprentissage automatique pour une très bonne raison.

Le traitement automatique du langage naturel pour la traduction est un modèle d'apprentissage en profondeur depuis le début des années 2000. Vers 2013, la mémoire longue à court terme (LSTM) a fait ses débuts dans le domaine et a dominé pendant quelques années. Un modèle LTSM lit la phrase, crée une représentation masquée, puis utilise la représentation masquée pour générer la phrase de sortie.

En tant qu'êtres humains, si nous traduisons, nous ne nous contentons pas de lire la phrase et de recracher la traduction. Nous avons tendance à regarder la phrase entière encore et encore, ou nous nous concentrons sur certaines parties lorsque nous voulons revoir le contexte du mot cible.

Par exemple le mot "lire". Représente-t-il le présent ou le passé ? Sur quelles autres parties de la phrase vous concentrez-vous pour déterminer cela ? Avez-vous besoin d'informations sur les phrases environnantes ? « Je lis des livres chaque année » signifie une chose en soi, mais si je disais : « J'ai fait beaucoup de choses avant d'aller à l'université. Je lis des livres chaque année. Je dînais tous les jours avec mes parents », la phrase prend un sens différent, et « lire » représente une action qui s'est déroulée au présent dans le premier exemple et au passé pour le second.

L'attention construit ces relations entre différents mots dans la phrase ou les phrases. Pour chaque mot que nous voulons traduire, il met en évidence différents mots dans la phrase originale en fonction de l'importance de ces mots associés avec le mot cible. Quelqu'un qui n'est pas un traducteur expérimenté ou professionnel pourrait simplement traduire mot à mot, et bien que les informations générales soient toujours transmises, la prise en compte de l'importance des mots associés lors de la traduction du mot cible produira une traduction beaucoup plus précise. L'attention nous permet d'intégrer ce modèle de traduction professionnelle dans l'architecture du modèle d'apprentissage en profondeur.

Pourquoi la connaissance du domaine est cruciale pour l'apprentissage automatique

Sans connaissance du domaine, vous pouvez cocher toutes les cases pour produire un modèle acceptable qui crache quelques chiffres. Grâce à la connaissance du domaine, vous saurez quelles données sont les meilleures à utiliser pour entraîner et tester votre modèle. Vous découvrirez également comment vous pouvez personnaliser le modèle que vous utilisez pour mieux représenter l'ensemble de données et le problème que vous essayez de résoudre, et comment tirer le meilleur parti des informations produites par votre modèle.

L'apprentissage automatique est une boîte à outils. Si vous sortez une scie électrique, vous réussirez probablement à couper du bois, mais vous ne pourrez probablement pas construire un tas d'armoires sans les connaissances expertes d'un menuisier. La connaissance du domaine vous permettra de porter l'impact de vos compétences en apprentissage automatique à un niveau d'importance beaucoup plus élevé.

Source :  https://www.kdnuggets.com

#machine-learning #ml