Utilisez des cas pour vous amener à comprendre les arbres de décision et à débloquer des informations

Cet article est partagé par Huawei Cloud Community « [Machine Learning | Decision Tree] Exploiter le potentiel des données : débloquer des informations avec des arbres de décision », auteur : Computer Magician.

arbre de décision

1.1 Classement

L'arbre de décision est un modèle de classification basé sur une structure arborescente, qui divise l'ensemble de données en plusieurs petites unités de prise de décision grâce à la division étape par étape des attributs de données. Chaque petite unité de décision correspond à un nœud feuille sur lequel les décisions de classification sont prises. Le cœur de l’arbre de décision est de savoir comment choisir l’attribut de segmentation optimal. Les algorithmes d'arbre de décision courants incluent ID3, C4.5 et CART.

Les données d'entrée de l'arbre de décision comprennent principalement un ensemble de formation et un ensemble de tests. L'ensemble d'apprentissage est un ensemble d'échantillons de catégories connues et l'ensemble de test est un ensemble d'échantillons inconnu qui doit être classé.

Plus précisément, le processus de création d’un arbre de décision peut être divisé en les étapes suivantes :

1. Sélectionnez les meilleures fonctionnalités. Lors de la construction d'un arbre de décision, il est nécessaire de sélectionner une caractéristique optimale dans l'ensemble d'échantillons actuel comme attribut de division du nœud actuel. Des indices tels que le gain d'informations, le taux de gain d'informations ou l'indice de Gini sont généralement utilisés pour évaluer la capacité de division de chaque fonctionnalité et sélectionner la fonctionnalité optimale.
2. Divisez en sous-ensembles. Selon les caractéristiques optimales sélectionnées, l'ensemble d'échantillons actuel est divisé en plusieurs sous-ensembles . Chaque sous-ensemble correspond à un nœud enfant, et l'ensemble d'échantillons représenté par ce nœud n'est pas répété avec l'ensemble d'échantillons de son nœud parent.
3. Construisez un arbre de décision de manière récursive. Pour chaque nœud enfant, répétez les deux premières étapes jusqu'à ce que tous les échantillons soient attribués aux nœuds feuilles et que chaque nœud feuille corresponde à une catégorie.
4. opération de taille. Étant donné que les arbres de décision sont sujets au surajustement, un élagage est nécessaire. Les méthodes de taille courantes incluent la pré-taille et la post-taille.

Lors de la classification, l'échantillon de test d'entrée est progressivement mis en correspondance selon la méthode de division de chaque attribut, et atteint finalement un certain nœud feuille, et l'échantillon de test est classé dans la catégorie représentée par le nœud feuille . Le résultat de l'arbre de décision est le résultat de la classification de l'échantillon de test, c'est-à-dire la catégorie à laquelle appartient l'échantillon de test.

Les avantages des arbres de décision sont qu'ils sont faciles à comprendre et à interpréter, qu'ils peuvent gérer différents types de données et qu'ils ne nécessitent pas de prétraitement des données . Cependant, les arbres de décision sont sujets à des problèmes de surajustement, des opérations d'élagage sont donc nécessaires lors de la construction des arbres de décision. Les méthodes de taille courantes incluent la pré-taille et la post-taille.

1.1.1 Cas

Supposons que nous souhaitions construire un arbre de décision pour prédire si une personne achètera un certain produit. Nous utiliserons les fonctionnalités suivantes pour faire des prédictions :

1. Âge : La tranche d’âge se situe entre 18 et 65 ans.
2. Sexe : masculin ou féminin.
3. Revenu : Le revenu varie de 0 à 100 000.

Nous disposons d'un ensemble de formation avec les données suivantes :

Nous allons maintenant utiliser ces données pour créer un modèle d'arbre de décision.

Tout d’abord, nous choisissons une fonctionnalité comme nœud racine. Nous pouvons utiliser des métriques telles que le gain d'informations ou l'impureté Gini pour sélectionner les meilleures fonctionnalités. Dans cet exemple, nous choisissons d'utiliser le gain d'information.

L'indice de Gini et le gain d'information sont tous deux des indicateurs utilisés pour la sélection de fonctionnalités dans les arbres de décision, et ils ont chacun leurs propres avantages et inconvénients.

L'indice de Gini est une mesure de la pureté ou de l'incertitude d'un ensemble de données et est souvent utilisé pour la sélection de caractéristiques dans les algorithmes d'arbre de décision. Il est basé sur le concept du coefficient de Gini , utilisé pour mesurer la probabilité que deux échantillons sélectionnés au hasard dans l'ensemble de données aient des étiquettes de classe incohérentes .

La formule de calcul de l'indice de Gini est la suivante :

Parmi eux, Gini(D) représente l'indice de Gini de l'ensemble de données D, et p_i représente la proportion d'échantillons de la i-ème catégorie dans l'ensemble de données D.

La plage de valeurs de l'indice de Gini va de 0 à 1, et plus la valeur est petite, plus la pureté de l'ensemble de données est élevée, c'est-à-dire plus la catégorie de l'échantillon est cohérente . Lorsque l'ensemble de données D ne contient qu'une seule catégorie d'échantillons, l'indice de Gini est de 0, indiquant que l'ensemble de données est complètement pur. Lorsque les catégories d'échantillons de l'ensemble de données D sont uniformément distribuées, l'indice de Gini est le plus grand (c'est-à-dire que la valeur est plus petite) et il est égal à 1, ce qui indique que l'incertitude de l'ensemble de données est la plus élevée.

Dans l'algorithme de l'arbre de décision, l'indice de Gini est utilisé pour mesurer le degré d'amélioration de la pureté de l'ensemble de données après avoir sélectionné une certaine caractéristique à diviser. En calculant l'indice de Gini de chaque entité, l'entité ayant l'indice de Gini le plus petit est sélectionnée comme base de division, de manière à minimiser l'incertitude de l'ensemble de données.

Calculez le gain d'informations pour chaque fonctionnalité :

• Gain d'information pour l'âge : 0,029
• Gain d'information pour le genre : 0,152
• Gain d'information de revenu : 0,048

En fonction du gain d'informations, nous choisissons le sexe comme nœud racine.

Le gain d'informations est une métrique utilisée pour sélectionner les nœuds de l'arbre de décision, qui mesure dans quelle mesure la pureté de l'ensemble de données s'améliore après la sélection d'une certaine fonctionnalité en tant que nœud . Le calcul du gain d'information est basé sur le concept d'entropie de l'information.

L'entropie de l'information est une mesure utilisée pour mesurer le degré de chaos ou d'incertitude d'un ensemble de données. Pour un problème à deux catégories (comme acheter ou non), la formule de calcul de l'entropie de l'information est la suivante (le multi-catégorie est le même, chaque catégorie est additionnée) :

Parmi eux, S est l'ensemble de données, et p(Oui) et p(Non) sont les proportions d'échantillons achetés comme « Oui » et « Non » dans l'ensemble de données, respectivement. ( L'entropie de l'information signifie que plus la distribution est moyenne, plus le contenu de l'information de l'échantillon est élevé, plus l'incertitude est grande, plus l'entropie de l'information est grande, plus la distribution est inégale, plus la proportion est grande et l'entropie de l'information tendra vers 0 .Par conséquent, il est déterminé par la taille de l'entropie de l'information.La classification consiste à séparer certaines collections à petite échelle )

La formule de calcul du gain d’information est la suivante (ajout de différentes catégories d’entropie informationnelle) :

Parmi eux, S est l'ensemble de données, A est la caractéristique permettant de calculer le gain d'information, Sv est le sous-ensemble correspondant à une certaine valeur de la caractéristique A, |Sv| est le nombre d'échantillons du sous-ensemble Sv, |S| est le échantillon de l’ensemble de données quantité S.  (Grâce au nombre de sous-ensembles pour contrôler son poids d'influence, puis déterminer le gain d'information le plus important ( c'est-à-dire la plus petite entropie d'information ), la langue vernaculaire consiste à choisir une classification plus courante et présentant des caractéristiques plus évidentes)

Plus le gain d'informations est important, cela signifie que l'utilisation de la fonctionnalité A comme nœud peut mieux segmenter l'ensemble de données et améliorer la pureté.

Dans notre cas, nous avons calculé le gain d'informations de chaque fonctionnalité et sélectionné la fonctionnalité avec le gain d'informations le plus important comme nœud racine. Ensuite, nous divisons l'ensemble de données en sous-ensembles en fonction de la valeur du nœud racine et calculons le gain d'informations pour chaque sous-ensemble afin de sélectionner le nœud suivant. Ce processus se poursuit jusqu'à ce qu'une condition d'arrêt soit remplie, par exemple que les échantillons du sous-ensemble appartiennent tous à la même classe ou qu'une profondeur d'arborescence prédéterminée soit atteinte.

Pour résumer, voici les avantages et les inconvénients de l'indice de Gini et du gain d'informations.

avantage:

• Indice de Gini : L'indice de Gini est une mesure d'impureté qui est plus simple et plus efficace sur le plan informatique que le gain d'informations . Lorsqu'il s'agit d'ensembles de données à grande échelle, la vitesse de calcul de l'indice de Gini est généralement plus rapide que le gain d'informations . (Calculez simplement la proportion de classification des caractéristiques, le carré de la proportion )
• Gain d'informations : le gain d'informations est une mesure de la contribution d'une fonctionnalité à une tâche de classification . Il est basé sur les concepts de la théorie de l'information, qui permet de mieux gérer les problèmes de multi-classification . Le gain d'informations fonctionne mieux lorsqu'il s'agit d'ensembles de données déséquilibrés et peut mieux gérer la situation de déséquilibre de classe. (En plus du calcul de la proportion de classification des fonctionnalités, une fonction log est ajoutée et le ratio log est multiplié par la proportion pour augmenter la proportion de la catégorie de contribution .)

défaut:

• Indice de Gini : L'indice de Gini ne prend en compte que l'impureté de la caractéristique, mais ne prend pas en compte le nombre de valeurs de la caractéristique. Cela signifie que l'indice de Gini peut être biaisé en faveur des caractéristiques ayant plus de valeurs. Lorsqu'il s'agit d'entités avec un grand nombre de valeurs, l'indice de Gini peut entraîner un biais de l'arbre de décision en faveur de ces entités. (Tant que l'indice de Gini a besoin de ce seuil, le nœud, la proportion maximale d'échantillons pouvant être divisés, plus le maximum est grand, plus il est incliné)
• Gain d'information : le gain d'information a une certaine préférence pour les entités avec plus de valeurs, car il a tendance à sélectionner des entités avec plus de branches . Cela peut conduire à un arbre de décision trop complexe et sujet au surajustement des données d'entraînement (la profondeur de l'arbre ne doit pas être trop profonde). (Le gain d'information est basé sur une sorte d'entropie de l'information informatique, selon sa nature, plus la classification est moyenne, plus la classification est grande et plus la proportion de classification est petite, pour diviser les nœuds.

En résumé, l'indice de Gini et le gain d'information présentent différents avantages et inconvénients selon les situations. Dans les applications pratiques, des indicateurs appropriés peuvent être sélectionnés en fonction de problèmes spécifiques et des caractéristiques des ensembles de données.

Ensuite, nous divisons l'ensemble de données en deux sous-ensembles en fonction de la valeur du sexe (homme ou femme).

Pour le sous-ensemble masculin :

Pour le sous-ensemble féminin :

Pour le sous-ensemble masculin, nous pouvons voir que le résultat est à la fois « oui » et « non », nous devons donc diviser davantage . Nous choisissons l'âge comme nœud suivant.

Pour la valeur de l'âge (inférieur ou égal à 30 ans et supérieur à 30 ans) :

Pour le sous-ensemble ≤ 30 ans :

numéro de série	revenu	Acheter
1	30 000	Non
4	10 000	Non
7	50 000	Non

Pour le sous-ensemble de plus de 30 ans :

numéro de série	revenu	Acheter
5	60 000	Oui

Pour le sous-ensemble des 30 ans ou moins, le résultat de l'achat est « non », nous n'avons donc pas besoin de le diviser.

Pour le sous-ensemble de plus de 30 ans, les résultats d'achat sont tous « oui », nous n'avons donc pas besoin de diviser à nouveau.

Pour le sous-ensemble féminin, le résultat de l’achat est « oui », nous n’avons donc pas besoin de le diviser.

L'arbre de décision final ressemble à ceci :

Sexe = Homme : 

Âge <= 30 : Non 

Âge > 30 : Oui 

Sexe = Féminin : Oui

Ceci est un exemple d’arbre de décision simple. Selon les caractéristiques d'entrée, l'arbre de décision peut faire des prédictions basées sur la valeur des caractéristiques. Notez qu'il ne s'agit que d'un exemple simple, en réalité, les arbres de décision peuvent avoir plus de fonctionnalités et des structures plus complexes.

Tout d'abord, nous utilisons la bibliothèque scikit-learn pour implémenter un arbre de décision :

à partir de sklearn import tree 

import numpy as np 

# dataset 

X = np.array([[25, 1, 30000], 

[35, 0, 40000], 

[45, 0, 80000], 

[20, 1, 10000], 

[ 55, 1, 60 000], 

[60, 0, 90 000], 

[30, 1, 50 000], 

[40, 0, 75 000]]) 

Y = np.array([0, 0, 1, 0, 1, 1 , 0, 1]) 

# créer un modèle d'arbre de décision 

clf = tree.DecisionTreeClassifier() 

# entraîner le modèle 

clf = clf.fit(X, Y) 

# prédire 

print(clf.predict([[40, 0, 75000],[ 10 , 0, 75000]])) # sortie : [1, 0]

Ensuite, nous implémentons un arbre de décision sans utiliser de bibliothèque de machine learning :

importer numpy en tant que classe np Noeud : 

def __init__(self, Predicted_class) : 

self.predicted_class = Predicted_class # Catégorie prédite 

self.feature_index = 0 # Index des fonctionnalités 

self.threshold = 0 # Seuil 

self.left = Aucun # Sous-arbre gauche 

self.right = Aucun # classe de sous-arbre droit 

DecisionTree: 

def __init__(self, max_degree=None): 

self.max_degree = max_degree # profondeur maximale de l'arbre de décision 

def fit(self, X, y): 

self.n_classes_ = len(set(y )) # Nombre de catégories 

self.n_features_ = X.shape[1] # Nombre de fonctionnalités 

self.tree_ = self._grow_tree(X, y) # Construire un arbre de décision 

def predict(self, X) : 

return [self._predict( inputs) pour les entrées dans X] # Prédire les données d'entrée 



def _best_gini_split(self, X, y): 

m = y.size # Le nombre d'échantillons

if m <= 1 : # Si le nombre d'échantillons est inférieur ou égal à 1, il ne peut pas être divisé 

return None, None 

num_parent = [np.sum(y == c) for c in range(self.n_classes_)] # Chaque catégorie est dans le nœud parent Le nombre d'échantillons dans 

best_gini = 1.0 - sum((n / m) ** 2 for n in num_parent) # L'indice Gini du nœud parent 

best_idx, best_thr = None, None # Meilleure segmentation index de fonctionnalité et seuil 

pour idx in range(self .n_features_): # parcourir chaque 

seuil de fonctionnalité, classes = zip(*sorted(zip(X[:, idx], y))) # trier les échantillons en fonction des valeurs de fonctionnalité 

num_left = [0] * self.n_classes_ # left Le nombre d'échantillons de chaque catégorie dans le nœud enfant 

num_right = num_parent.copy() # Le nombre d'échantillons de chaque catégorie dans le nœud enfant droit, la valeur initiale est le nombre d'échantillons du nœud parent 

pour i in range(1, m): # Parcourir chaque échantillon 

c = classes[i - 1] # catégorie de l'échantillon 

num_left[c] += 1 # mettre à jour le nombre d'échantillons de la catégorie correspondante dans le nœud enfant gauche 

num_right[c] -= 1 # mettre à jour le nombre d'échantillons de la catégorie correspondante dans le nœud enfant droit 

gini_left = 1.0 - sum(

(num_left[x] / i) ** 2 pour x in range(self.n_classes_) 

) # Index Gini du nœud enfant gauche 

gini_right = 1.0 - sum( 

(num_right[x] / (m - i)) ** 2 for x in range(self.n_classes_) 

) # Indice de Gini du nœud enfant droit 

gini = (i * gini_left + (m - i) * gini_right) / m # Indice de Gini moyen pondéré 

si seuils[i] == seuils[i - 1] : # Si les valeurs des fonctionnalités sont les mêmes, ignorer (seuil de fonctionnalité) 

continuer 

si gini < best_gini : # Si l'index Gini est plus petit, mettre à jour l'index et le seuil des meilleures fonctionnalités de segmentation (boucler chaque fonctionnalité et chaque seuil , pour résoudre la classification optimale 

best_gini = gini 

best_idx = idx 

best_thr = (thresholds[i] + seuils[i - 1]) / 2 

return best_idx, best_thr # Renvoie le meilleur index et seuil de fonctionnalité de segmentation 

def _best_gain_split(self, X, y ): 

m = y.size # Le nombre d'échantillons 

si m <= 1 : # Si le nombre d'échantillons est inférieur ou égal à 1, il ne peut pas être divisé 

return Aucun, Aucun

num_parent = [np.sum(y == c) for c in range(self.n_classes_)] # calculer le nombre d'échantillons pour chaque catégorie 

best_gain = -1 # initialiser le meilleur gain d'informations 

best_idx, best_thr = Aucun, Aucun # initialiser le meilleur meilleur indice de fonctionnalité et seuil 

pour idx dans la plage (self.n_features_) : # traverse chaque 

seuil de fonctionnalité, classes = zip(*sorted(zip(X[:, idx], y))) # pour chaque valeur et catégorie de fonctionnalité Les étiquettes sont triées 

num_left = [0] * self.n_classes_ # Initialise le nombre de catégories dans le sous-arbre de gauche (le côté gauche est 0, et il est automatiquement calculé comme 0 lorsqu'il est 0) 

num_right = num_parent.copy() # Le le nombre de catégories dans le sous-arbre de droite est initialisé comme Le nombre de catégories du nœud parent (la droite est tout) 

pour i dans range(1, m) : # traverse chaque échantillon 

c = classes[i - 1] # récupère la catégorie de l'échantillon actuel 

num_left[c] += 1 # sous-arbre gauche Le nombre de catégories augmente 

num_right[c] -= 1 # Le nombre de catégories dans le sous-arbre droit diminue 

entropy_parent = -sum((num / m) * np.log2 (num/m) pour num dans num_parent si num != 0) # calcul de l'entropie du nœud parent

entropy_left = -sum((num / i) * np.log2(num / i) for num in num_left if num != 0) # Calculer l'entropie du sous-arbre gauche entropy_right = -sum(( num / (m - i 

) ) * np.log2(num / (m - i)) for num in num_right if num != 0) # Calculer l'entropie du sous-arbre droit 

gain = entropy_parent - (i * entropy_left + (m - i) * entropy_right) / m # Calculer le gain d'information (l'entropie d'information gauche et droite après classification est la plus petite) 

si seuils[i] == seuils[i - 1] : # Si la valeur propre de l'échantillon actuel est la même que la valeur propre de l'échantillon précédent , sauter (les différents peuvent être divisés) 

continuer 

si gain > best_gain : # Si le gain d'informations actuel est supérieur au meilleur gain d'informations best_gain 

= gain # Mettre à jour le meilleur gain d'informations 

best_idx = idx # Mettre à jour le meilleur index de fonctionnalités 

best_thr = (seuils[ i] + seuils[i - 1]) / 2 # Mettre à jour le meilleur seuil (faire défiler la valeur de chaque échantillon, déterminer le seuil en fonction de la moyenne des deux données et continuer la boucle) return best_idx, best_thr # Renvoie la meilleure 

fonctionnalité index et seuil 

def _grow_tree(self, X, y, profondeur=0 ):

num_samples_per_class = [np.sum(y == i) for i in range(self.n_classes_)] # Calculer le nombre d'échantillons dans chaque catégorie 

Predicted_class = np.argmax(num_samples_per_class) # La catégorie prédite est la catégorie avec le plus grand nombre d'échantillons (c'est-à-dire Déterminer la classe qui a le plus d'échantillons affectés à cette branche) 

node = Node(predicted_class=predicted_class) # Créer un nœud 

si profondeur < self.max_degree : # Si la profondeur actuelle est inférieure à la profondeur maximale 

idx, thr = self._best_gain_split(X, y) # Calcule la meilleure segmentation 

si idx n'est pas Aucun : # S'il existe une segmentation optimale 

indices_left = X[:, idx] < thr # L'index échantillon du sous-arbre gauche (l'index du idx est inférieur au seuil thr) X_left 

, y_left = X [indices_left], y[indices_left] # Échantillons du sous-arbre gauche 

X_right, y_right = X[~indices_left], y[~indices_left] # Échantillons du 

nœud du sous-arbre droit. feature_index = idx # Définir l'index des fonctionnalités du 

nœud node.threshold = thr # Définir le seuil du nœud 

node.left = self._grow_tree(X_left, y_left, profondeur + 1) # Construire le sous-arbre de gauche

node.right = self._grow_tree(X_right, y_right, deep + 1) # construire le sous-arbre droit 

return node # return node 

def _predict(self, inputs): 

node = self.tree_ # obtenir le nœud racine de l'arbre de décision 

while node .left : # S'il y a un sous-arbre gauche 

if inputs[node.feature_index] < node.threshold : # Si la valeur de caractéristique de l'échantillon d'entrée est inférieure au seuil 

node = node.left # au sous-arbre gauche 

else : 

node = node.right # au sous-arbre droit 

return node.predicted_class # Renvoie la catégorie prédite 

# Ensemble de données 

X = [[25, 1, 30000], 

[35, 0, 40000], 

[45, 0, 80000], 

[20, 1, 10000], 

[55, 1, 60000], 

[60, 0, 90000], 

[30, 1, 50000], 

[40, 0, 75000]] 

Y = [0, 0, 1, 0, 1, 1, 0, 1] 

# créer un modèle d'arbre de décision 

clf = DecisionTree(max_degree=2) 

# modèle de formation

clf.fit(np.array(X), np.array(Y)) 

# prédiction 

print(clf.predict([[40, 0, 75000],[10, 0, 75000]])) # sortie : [1 , 0]

Notez que cette implémentation d'arbres de décision sans utiliser de bibliothèque d'apprentissage automatique est une version de base et qu'elle peut ne pas gérer tous les cas tels que les valeurs manquantes, les fonctionnalités catégorielles, etc. Dans les applications pratiques, nous utilisons généralement des bibliothèques d'apprentissage automatique matures, telles que scikit-learn, car elles offrent plus de fonctions et d'optimisations.

1.2 régression

Lorsqu'un arbre de décision est utilisé pour une tâche de régression, on l'appelle un modèle de régression d'arbre de décision. Contrairement à l'arbre de classification, les nœuds feuilles du modèle de régression de l'arbre de décision ne représentent plus des étiquettes de catégorie, mais représentent un intervalle continu ou une valeur . Il est également basé sur une structure arborescente et divise l'ensemble de données en plusieurs petites unités de prise de décision grâce à la division étape par étape des caractéristiques des données, et génère une valeur prédite sur chaque nœud feuille.

Voici le principe détaillé du modèle de régression d’arbre de décision :

1. Processus de division

Semblable à l'arbre de classification, le modèle de régression de l'arbre de décision est également divisé par une dichotomie récursive. Plus précisément, à partir du nœud racine, une caractéristique optimale et le point de division optimal de cette caractéristique sont sélectionnés. Ensuite, l'ensemble de données est divisé en deux parties en fonction de la valeur de la caractéristique, et les sous-arbres gauche et droit sont construits respectivement. Répétez les étapes ci-dessus jusqu'à ce que la condition d'arrêt soit remplie, comme atteindre la profondeur maximale, le nombre d'échantillons divisés est inférieur au seuil, etc.

2. La valeur de sortie du nœud feuille

Lorsqu'un nœud feuille est atteint, la valeur de sortie du nœud feuille est la moyenne (ou médiane, etc.) de tous les échantillons correspondant au nœud feuille dans l'ensemble d'apprentissage .

3. Processus de prédiction

Pour un échantillon de test, commencez par le nœud racine, faites la correspondance étape par étape selon la méthode de division de chaque caractéristique, et enfin atteignez un certain nœud feuille, et définissez la valeur prédite de l'échantillon de test comme valeur de sortie du nœud feuille.

4. Opération de taille

Comme les arbres de classification, les modèles de régression d'arbre de décision sont sujets à des problèmes de surajustement, un élagage est donc nécessaire. Les méthodes de taille courantes incluent la pré-taille et la post-taille.

5. Caractéristiques

Un modèle de régression d'arbre de décision présente les caractéristiques suivantes :

(1) Facile à expliquer : le modèle de régression d'arbre de décision peut refléter intuitivement le degré d'influence de chaque caractéristique sur la variable cible.

(2) Non paramétrique : le modèle de régression d'arbre de décision ne fait aucune hypothèse sur la distribution des données et est applicable à différents types de données.

(3) Plusieurs fonctionnalités peuvent être traitées : le modèle de régression d'arbre de décision peut traiter plusieurs fonctionnalités d'entrée en même temps.

(4) La normalisation des données n'est pas requise : le modèle de régression d'arbre de décision ne nécessite pas de prétraitement tel que la normalisation des données d'entrée.

Supplémentaire

Huawei organisera le 8e HUAWEI CONNECT 2023 au Shanghai World Expo Exhibition Hall et au Shanghai World Expo Center du 20 au 22 septembre 2023. Ayant pour thème « Accélérer l'intelligence industrielle », cette conférence invite les leaders d'opinion, les élites commerciales, les experts techniques, les partenaires, les développeurs et d'autres collègues de l'industrie à discuter de la manière d'accélérer l'intelligence industrielle issue des entreprises, de l'industrie et de l'écologie.

Nous vous invitons sincèrement à venir sur le site, à partager les opportunités et les défis de l'intelligentisation, à discuter des mesures clés de l'intelligentisation et à découvrir l'innovation et l'application de la technologie intelligente. tu peux:

• Dans plus de 100 discours, sommets et forums, affrontez le point de vue de l'accélération de l'intelligence industrielle
• Visitez la zone d'exposition de 17 000 mètres carrés pour découvrir de près l'innovation et l'application de la technologie intelligente dans l'industrie.
• Rencontrez en personne des experts techniques pour en savoir plus sur les dernières solutions, outils de développement et activités pratiques.
• Rechercher des opportunités d'affaires avec les clients et partenaires

Merci pour votre soutien et votre confiance comme toujours, et nous avons hâte de vous rencontrer à Shanghai.

Site officiel de la conférence : https://www.huawei.com/cn/events/huaweiconnect

Bienvenue à suivre le compte officiel de la « Huawei Cloud Developer Alliance » pour obtenir l'ordre du jour de la conférence, des activités passionnantes et des produits secs de pointe.

Cliquez pour suivre et découvrir pour la première fois les nouvelles technologies de Huawei Cloud~

Redis 7.2.0 est sorti, la version la plus avancée, les programmeurs chinois ont refusé d'écrire des programmes de jeu, 14 dents ont été arrachées et 88 % du corps entier a été endommagé. Flutter 3.13 a été publié. System Initiative a annoncé que tous ses logiciels Être open source. La première application indépendante à grande échelle est apparue , Grace a changé son nom en " Doubao " Spring 6.1 est compatible avec les threads virtuels et JDK 21 Tablette Linux StarLite 5 : Ubuntu par défaut, Chrome 116 de 12,5 pouces officiellement publié Bureau redéployé de Red Hat Développement Linux, le développeur principal a été transféré Kubernetes 1.28 officiellement publié

{{o.name}}

{{m.nom}}