Comment utiliser Python pour le réglage hyperparamétrique

Communauté des sages 2021-10-29 18:23:33
comment utiliser python pour le

L'ampleur des différences entre les nombreuses sous - branches développées autour du thème de l'optimisation des modèles est souvent incroyable.Une de ces sous - branches est appelée optimisation hyperparamétrique,Ou réglage des paramètres.

Dans cet article, vous apprendrez:

  1. Superparameters in Machine Learning

  2. Conditions préalables et données

  3. Réglage de l'hyperparamètre de recherche de grille

  4. Réglage aléatoire des hyperparamètres de recherche

  5. Optimisation bayésienne des hyperparamètres

  6. Réduire de moitié la recherche en grille et réduire de moitié la recherche aléatoire

  7. Options alternatives

Superparameters in Machine Learning

Les hyperparamètres font partie de tous les algorithmes d'apprentissage automatique et d'apprentissage en profondeur.Avec les paramètres d'apprentissage machine standard appris par l'algorithme lui - même(Comme dans la régression linéaire w Et b,Ou poids de connexion dans un réseau neuronal)C'est différent.,.Les hyperparamètres sont définis par l'Ingénieur avant le processus de formation.

Ce sont des facteurs externes définis exclusivement par l'Ingénieur,Pour contrôler le comportement des algorithmes d'apprentissage.J'aimerais voir quelques exemples?Le taux d'apprentissage est l'un des hyperparamètres les plus connus,SVM Dans C C'est aussi un super paramètre,La profondeur maximale de l'arbre de décision est également un hyperparamètre,Attendez un peu!.Ces paramètres peuvent être réglés manuellement par l'Ingénieur.

Mais,Si on veut faire plusieurs tests,Les hyperparamètres peuvent être gênants à utiliser.Nous avons donc besoin d'optimiser les hyperparamètres.L'objectif principal de ces techniques est de trouver les meilleurs hyperparamètres pour un algorithme d'apprentissage machine donné,Pour obtenir la meilleure évaluation du rendement sur l'ensemble de validation.Dans ce tutoriel,Nous avons exploré plusieurs techniques pour vous fournir les meilleurs hyperparamètres.

Conditions préalables et données
Conditions préalables et bibliothèques

Veuillez installer ce qui suit Python Bibliothèque,Pour préparer le reste de cet article:

  • NumPy——Si vous avez besoin d'aide pour l'installation, Veuillez consulter ce guide (https://numpy.org/install/).

  • SciKit Learn——Si vous avez besoin d'aide pour l'installation, Veuillez consulter ce guide (https://scikit-learn.org/stable/install.html).

  • SciPy——Si vous avez besoin d'aide pour l'installation, Veuillez consulter ce guide (https://www.scipy.org/install.html).

  • Sci-Kit Optimization——Si vous avez besoin d'aide pour l'installation, Veuillez consulter ce guide (https://scikit-optimize.github.io/stable/install.html).

Une fois l'installation terminée,Assurez - vous d'avoir importé tous les modules nécessaires utilisés dans ce tutoriel.

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import f1_score

from sklearn.model_selection import GridSearchCV, RandomizedSearchCV

from sklearn.experimental import enable_halving_search_cv
from sklearn.model_selection import HalvingGridSearchCV, HalvingRandomSearchCV

from sklearn.svm import SVC
from sklearn.ensemble import RandomForestRegressor

from scipy import stats
from skopt import BayesSearchCV
from skopt.space import Real, Categorical

En plus de ça,,Vous feriez mieux de vous familiariser avec l'algèbre linéaire、Les bases du calcul et de la théorie des probabilités.

Préparation des données

Les données que nous utilisons ici proviennent de PalmerPenguins Ensemble de données.Cet ensemble de données est le plus récent,Conçu pour être célèbre comme Iris Solutions de rechange aux ensembles de données.Elle a été créée par Kristen Gorman Docteur et Antarctique LTER La station Palmer de.Vous pouvez être ici (https://github.com/allisonhorst/palmerpenguins) Ou par Kaggle Obtenir cet ensemble de données.

Cet ensemble de données se compose essentiellement de deux ensembles de données,Chaque ensemble de données contient 344 Les données pour les pingouins.C'est comme... Iris C'est pareil,Cet ensemble de données est également disponible dans les îles Palmer 3 Des îles 3 Une espèce de pingouin.En outre,Ces ensembles de données contiennent, pour chaque espèce culmen Dimensions.culmen C'est la crête supérieure du bec.Dans les données simplifiées sur les pingouins,culmen La longueur et la profondeur sont renommées variables culmen_length_mm Et culmen_depth_mm.

Comme cet ensemble de données a été marqué,Nous devrions être en mesure de valider nos résultats expérimentaux.Mais la réalité n'est pas toujours aussi simple,La validation des résultats des algorithmes de regroupement est souvent un processus difficile et complexe.

Commençons par charger et préparer PalmerPenguins Ensemble de données.Tout d'abord,,On charge l'ensemble de données,Supprimer les caractéristiques qui ne sont pas utilisées dans cet article:

data = pd.read_csv('./data/penguins_size.csv')

data = data.dropna()
data = data.drop(['sex', 'island', 'flipper_length_mm', 'body_mass_g'], axis=1)

Nous séparons ensuite les données d'entrée et les zoomons:

X = data.drop(['species'], axis=1)

ss = StandardScaler()
X = ss.fit_transform(X)

y = data['species']
spicies = {'Adelie': 0, 'Chinstrap': 1, 'Gentoo': 2}
y = [spicies[item] for item in y]
y = np.array(y)

Enfin,Nous avons divisé les données en ensembles de données de formation et d'essai:

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=33)

Quand nous cartographions les données ici,,L'image est la suivante:

Réglage de l'hyperparamètre de recherche de grille

Le travail de réglage des hyperparamètres est lent et ennuyeux à faire manuellement.Alors nous avons commencé à explorer le premier,C'est aussi la technique d'optimisation hyperparamétrique la plus simple——Recherche par grille.Cette technique peut accélérer le travail de réglage,Est l'une des techniques d'optimisation hyperparamétrique les plus couramment utilisées.Essentiellement,Il automatise le processus d'essai et d'erreur.Pour cette technologie,Nous fournissons une liste de toutes les valeurs des hyperparamètres,L'algorithme construit ensuite un modèle pour chaque combinaison possible,Pour l'évaluer,Et choisissez la valeur qui donne le meilleur résultat.C'est une technologie universelle,Peut être appliqué à n'importe quel modèle.

Dans notre exemple,Nous utilisons SVM Algorithme de classification.Nous avons considéré trois hyperparamètres——C、gamma Et kernel. Pour en savoir plus, consultez cet article (https://rubikscode.net/2020/08/10/back-to-machine-learning-basics-support-vector-machines/).Pour C,Nous allons vérifier les valeurs suivantes:0.1、1、100、1000;Pour gamma,Nous utilisons des valeurs:0.0001、0.001、0.005、0.1、1、3、5,Pour kernel,Nous utilisons des valeurs:“linear”Et“rbf”.

Mise en œuvre de la recherche en grille

Voici à quoi ressemble le Code:

hyperparameters = {
'C': [0.1, 1, 100, 1000],
'gamma': [0.0001, 0.001, 0.005, 0.1, 1, 3, 5],
'kernel': ('linear', 'rbf')
}

On a utilisé Sci-Kit Learn La bibliothèque et SVC Catégorie,Il contient SVM Mise en œuvre de la classification.En plus de ça,,On a aussi utilisé GridSearchCV Catégorie,Pour l'optimisation de la recherche en grille.Ensemble, c'est comme ça:

grid = GridSearchCV(
estimator=SVC(),
param_grid=hyperparameters,
cv=5,
scoring='f1_micro',
n_jobs=-1)

Cette classe reçoit plusieurs paramètres par l'intermédiaire du constructeur:

  • estimator——Exemple d'algorithme d'apprentissage automatique lui - même.C'est là qu'on passe SVC Nouvelle instance de la classe.

  • param_grid——Contient un dictionnaire d'hyperparamètres.

  • cv——Déterminer la stratégie de partage de la validation croisée.

  • scoring——Indicateurs de validation utilisés pour évaluer les prévisions.Nous utilisons F1 Points.

  • n_jobs——Indique le nombre d'emplois à exécuter en parallèle.Valeur -1 Indique que tous les processeurs sont utilisés.

Il ne reste plus qu'à utiliser fit Méthode exécuter le processus d'entraînement:

grid.fit(X_train, y_train)

Après la formation,Nous pouvons voir les meilleurs hyperparamètres et les scores de ces paramètres:

print(f'Best parameters: {grid.best_params_}')
print(f'Best score: {grid.best_score_}')
Best parameters: {'C': 1000, 'gamma': 0.1, 'kernel': 'rbf'}
Best score: 0.9626834381551361

En outre,Nous pouvons Imprimer tous les résultats:

print(f'All results: {grid.cv_results_}')
Allresults: {'mean_fit_time': array([0.00780015, 0.00280147, 0.00120015, 0.00219998, 0.0240006 ,
0.00739942, 0.00059962, 0.00600033, 0.0009994 , 0.00279789,
0.00099969, 0.00340114, 0.00059986, 0.00299864, 0.000597 ,
0.00340023, 0.00119658, 0.00280094, 0.00060058, 0.00179944,
0.00099964, 0.00079966, 0.00099916, 0.00100031, 0.00079999,
0.002 , 0.00080023, 0.00220037, 0.00119958, 0.00160012,
0.02939963, 0.00099955, 0.00119963, 0.00139995, 0.00100069,
0.00100017, 0.00140052, 0.00119977, 0.00099974, 0.00180006,
0.00100312, 0.00199976, 0.00220003, 0.00320096, 0.00240035,
0.001999 , 0.00319982, 0.00199995, 0.00299931, 0.00199928,
...

D'accord.,Maintenant, construisons ce modèle et vérifions sa performance sur l'ensemble de données d'essai:

model = SVC(C=500, gamma = 0.1, kernel = 'rbf')
model.fit(X_train, y_train)


preditions = model.predict(X_test)
print(f1_score(preditions, y_test, average='micro'))
0.9701492537313433

Ça s'est bien passé,Notre modèle est approximatif avec les hyperparamètres recommandés 97% Précision.Voici à quoi ressemble le modèle au moment du dessin:

Réglage aléatoire des hyperparamètres de recherche

La recherche en grille est très simple,Mais son coût de calcul est également élevé.En particulier dans le domaine de l'apprentissage profond,L'entraînement peut prendre beaucoup de temps.En outre,Certains hyperparamètres peuvent être plus importants que d'autres.L'idée d'une recherche aléatoire,Cet article est suivi d'une introduction spécifique à.En fait,Cette étude montre que,La recherche aléatoire est plus avantageuse pour calculer le coût de l'optimisation hyperparamétrique que la recherche en grille.Cette technique nous permet également de découvrir plus précisément les valeurs idéales des hyperparamètres importants.

Comme une recherche en grille,La recherche aléatoire crée une grille numérique hyperparamétrique et sélectionne des combinaisons aléatoires pour former le modèle.Cette approche peut manquer la meilleure combinaison,Mais comparé à la recherche en grille,Il est plus susceptible de choisir le meilleur résultat,Et il ne faut qu'une petite partie du temps de recherche de la grille.

Mise en œuvre de la recherche aléatoire

Voyons comment c'est écrit en Code.Nous utilisons à nouveau Sci-KitLearn De la bibliothèque SVC Catégorie,Mais cette fois, on utilise RandomSearchCV Classe pour l'optimisation de la recherche aléatoire.

hyperparameters = {
"C": stats.uniform(500, 1500),
"gamma": stats.uniform(0, 1),
'kernel': ('linear', 'rbf')
}
random = RandomizedSearchCV(
estimator = SVC(),
param_distributions = hyperparameters,
n_iter = 100,
cv = 3,
random_state=42,
n_jobs = -1)
random.fit(X_train, y_train)

Votre attention, s'il vous plaît.,Nous sommes d'accord avec C Et gamma Distribution uniforme utilisée.Encore une fois,On peut imprimer les résultats:

print(f'Best parameters: {random.best_params_}')
print(f'Best score: {random.best_score_}')
Best parameters: {'C': 510.5994578295761, 'gamma': 0.023062425041415757, 'kernel': 'linear'}
Best score: 0.9700374531835205

Vous pouvez voir que nos résultats sont proches de la recherche en grille,Mais ce n'est pas pareil.Hyperparamètres pour la recherche en grille C La valeur de 500,Et la valeur de la recherche aléatoire est 510.59.De ce seul point vous pouvez voir les avantages de la recherche aléatoire,Parce qu'il est peu probable que nous mettions cette valeur dans la liste de recherche de la grille.De même,,Pour gamma,Nos résultats de recherche aléatoires sont 0.23,Et la recherche par grille est 0.1.Ce qui est vraiment surprenant, c'est que la recherche aléatoire a choisi la linéarité kernel Au lieu de RBF,Et il a obtenu plus haut F1 Points.Pour imprimer tous les résultats,Nous utilisons cv_results_ Propriétés:

print(f'All results: {random.cv_results_}')
Allresults: {'mean_fit_time': array([0.00200065, 0.00233404, 0.00100454, 0.00233777, 0.00100009,
0.00033339, 0.00099715, 0.00132942, 0.00099921, 0.00066725,
0.00266568, 0.00233348, 0.00233301, 0.0006667 , 0.00233285,
0.00100001, 0.00099993, 0.00033331, 0.00166742, 0.00233364,
0.00199914, 0.00433286, 0.00399915, 0.00200049, 0.01033338,
0.00100342, 0.0029997 , 0.00166655, 0.00166726, 0.00133403,
0.00233293, 0.00133729, 0.00100009, 0.00066662, 0.00066646,

....

Répétez les étapes de la recherche sur la grille ci - dessus:Créer un modèle avec les hyperparamètres recommandés,Vérifier les scores de l'ensemble de données d'essai et dessiner le modèle.

model = SVC(C=510.5994578295761, gamma = 0.023062425041415757, kernel = 'linear')
model.fit(X_train, y_train)
preditions = model.predict(X_test)
print(f1_score(preditions, y_test, average='micro'))
0.9701492537313433

Ouah!,Sur l'ensemble de données d'essai F1 Les scores sont exactement les mêmes que lorsque nous avons utilisé la recherche par grille.Voir le modèle:

Optimisation bayésienne des hyperparamètres

Les deux premiers algorithmes sont un peu géniaux,C'est - à - dire que toutes les expériences utilisant différentes valeurs de superparamètres peuvent Parallèle Exécution.Ça nous fera gagner beaucoup de temps.Mais c'est aussi leur plus grand défaut.Parce que chaque expérience fonctionne isolément,Nous ne pouvons pas utiliser l'information provenant d'expériences antérieures dans les expériences actuelles.Il existe un domaine dédié à la résolution des problèmes d'optimisation des séquences——Optimisation des séquences basée sur des modèles(SMBO).Les algorithmes explorés dans ce domaine utiliseront des expériences antérieures et des observations sur les fonctions de perte,Et ensuite, à partir d'eux, on essaie de déterminer le prochain meilleur point.Un de ces algorithmes est l'optimisation bayésienne.

Ce genre d'algorithme vient de SMBO Les autres algorithmes du Groupe sont les mêmes,En utilisant les points précédemment évalués(Il s'agit ici de la valeur du superparamètre,Mais on peut généraliser)Pour calculer les attentes a posteriori de la fonction de perte.L'algorithme utilise deux concepts mathématiques importants——Processus gaussien Et Fonction d'acquisition.Puisque la distribution gaussienne se fait sur des variables aléatoires,Donc le processus gaussien est sa généralisation de la fonction.Tout comme la distribution gaussienne a des moyennes et des Covariances,Le processus gaussien est décrit par la fonction moyenne et la fonction de covariance.

La fonction d'acquisition est la fonction que nous utilisons pour évaluer la valeur actuelle de la perte.On peut le considérer comme une fonction de perte d'une fonction de perte.C'est une fonction de distribution a posteriori de la fonction de perte,Décrit l'utilité de toutes les valeurs hyperparamétriques.La fonction de collecte la plus populaire est Expected Improvement(EI):

Parmi eux f Est une fonction de perte,x'Est l'ensemble optimal actuel de superparamètres.Quand on les a réunis,Bayes Optimized score 3 Étapes terminées:

  • En utilisant les points de fonction de perte précédemment évalués,Calculer les attentes a posteriori en utilisant le processus gaussien.

  • Choisissez maximiser EI Nouvel ensemble de points pour

  • Calculer la fonction de perte pour le nouveau point de sélection

Mise en œuvre de l'optimisation bayésienne

La façon la plus simple de l'introduire dans le Code est d'utiliser Sci-Kit optimization Bibliothèque,Communément appelé skopt.Suivez la procédure que nous avons utilisée dans l'exemple précédent,Nous pouvons faire ce qui suit::

hyperparameters = {
"C": Real(1e-6, 1e+6, prior='log-uniform'),
"gamma": Real(1e-6, 1e+1, prior='log-uniform'),
"kernel": Categorical(['linear', 'rbf']),
}
bayesian = BayesSearchCV(
estimator = SVC(),
search_spaces = hyperparameters,
n_iter = 100,
cv = 5,
random_state=42,
n_jobs = -1)
bayesian.fit(X_train, y_train)

Encore une fois,Nous avons défini un dictionnaire pour l'ensemble des hyperparamètres.Votre attention, s'il vous plaît.,Nous avons utilisé Sci-Kit Optimiser les Real Et Categorical Catégorie.Ensuite, nous utilisons et utilisons GridSearchCV Ou RandomSearchCV .Les classes sont utilisées de la même manière BayesSearchCV Catégorie.Après la formation,Nous pouvons imprimer les meilleurs résultats:

print(f'Best parameters: {bayesian.best_params_}')
print(f'Best score: {bayesian.best_score_}')
Best parameters: 
OrderedDict([('C', 3932.2516133086), ('gamma', 0.0011646737978730447), ('kernel', 'rbf')])
Best score: 0.9625468164794008

C'est marrant.,N'est-ce pas??Avec cette optimisation, nous obtenons des résultats complètement différents.Les pertes sont un peu plus élevées que lorsque nous avons utilisé la recherche aléatoire.On peut même Imprimer tous les résultats:

print(f'All results: {bayesian.cv_results_}')
All results: defaultdict(<class 'list'>, {'split0_test_score': [0.9629629629629629,
0.9444444444444444, 0.9444444444444444, 0.9444444444444444, 0.9444444444444444,
0.9444444444444444, 0.9444444444444444, 0.9444444444444444, 0.46296296296296297,
0.9444444444444444, 0.8703703703703703, 0.9444444444444444, 0.9444444444444444,
0.9444444444444444, 0.9444444444444444, 0.9444444444444444, 0.9444444444444444,
.....

Comment les modèles utilisant ces hyperparamètres se comportent sur les ensembles de données d'essai?Voyons voir:

model = SVC(C=3932.2516133086, gamma = 0.0011646737978730447, kernel = 'rbf')
model.fit(X_train, y_train)
preditions = model.predict(X_test)
print(f1_score(preditions, y_test, average='micro'))
0.9850746268656716

C'est très intéressant..Bien que nous ayons obtenu des résultats inférieurs sur l'ensemble de données de validation,Mais nous avons obtenu de meilleurs résultats sur l'ensemble de données d'essai.Voici le modèle:

Plus de plaisir,On peut mettre tous ces modèles côte à côte:

Réduire de moitié la recherche en grille et réduire de moitié la recherche aléatoire

Il y a quelques mois,Sci-Kit Learn La Bibliothèque a introduit deux nouvelles classes,HalvingGridSearchCV Et HalvingRandomSearchCV.Ils affirment que,Ces deux catégories“Une combinaison idéale de paramètres peut être trouvée plus rapidement”.Ces classes utilisent la méthode de la moitié continue pour rechercher les valeurs de paramètres spécifiées.La technologie a commencé à utiliser de petites ressources pour évaluer tous les candidats,Et utiliser de plus en plus de ressources pour sélectionner itérativement les meilleurs candidats.

Du point de vue de la moitié de la recherche sur la grille,Cela signifie que dans la première itération,Tous les candidats s'entraîneront sur une petite quantité de données d'entraînement.La prochaine itération n'inclura que les candidats qui ont obtenu les meilleurs résultats de l'itération précédente,Ces modèles recevront plus de ressources,C'est - à - dire plus de données d'entraînement,Ensuite, on fera une évaluation.Le processus se poursuivra,Et la moitié de la recherche en grille ne conservera que les meilleurs candidats de l'itération précédente,Jusqu'au dernier.

Tout le processus est contrôlé par deux paramètres——min_samples Et factor.Premier paramètre min_samples Indique la quantité de données au début du processus.À chaque itération,L'ensemble de données sera appuyé sur factor Augmentation de la valeur définie.Le processus est similaire à HalvingRandomSearchCV.

Mise en œuvre de la moitié de la recherche en grille et de la moitié de la recherche aléatoire

Le Code ici est similaire à l'exemple précédent,Nous avons juste utilisé différentes classes.Commençons par HalvingGridSearch C'est parti.:

hyperparameters = {
'C': [0.1, 1, 100, 500, 1000],
'gamma': [0.0001, 0.001, 0.01, 0.005, 0.1, 1, 3, 5],
'kernel': ('linear', 'rbf')
}


grid = HalvingGridSearchCV(
estimator=SVC(),
param_grid=hyperparameters,
cv=5,
scoring='f1_micro',
n_jobs=-1)
grid.fit(X_train, y_train)

Ce qui est intéressant, c'est que ce code ne fonctionne que 0.7 Secondes.En comparaison,Utiliser GridSearchCV Le même code pour la classe s'est enfui 3.6 Secondes.Le premier est beaucoup plus rapide,Mais les résultats sont un peu différents:

print(f'Best parameters: {grid.best_params_}')
print(f'Best score: {grid.best_score_}')
Best parameters: {'C': 500, 'gamma': 0.005, 'kernel': 'rbf'}
Best score: 0.9529411764705882

Nous avons obtenu des résultats similaires,Mais ce n'est pas pareil.Si nous créons un modèle avec ces valeurs, nous obtiendrons la précision et les graphiques suivants:

model = SVC(C=500, gamma = 0.005, kernel = 'rbf')
model.fit(X_train, y_train)
preditions = model.predict(X_test)
print(f1_score(preditions, y_test, average='micro'))
0.9850746268656716

Ensuite, nous répétons le processus ci - dessus pour une recherche aléatoire de moitié.C'est drôle,En utilisant cette méthode, nous obtenons les résultats les plus étranges.Nous pouvons dire que les modèles créés de cette façon sont difficiles à adapter:

hyperparameters = {
"C": stats.uniform(500, 1500),
"gamma": stats.uniform(0, 1),
'kernel': ('linear', 'rbf')
}
random = HalvingRandomSearchCV(
estimator = SVC(),
param_distributions = hyperparameters,
cv = 3,
random_state=42,
n_jobs = -1)
random.fit(X_train, y_train)
print(f'Best parameters: {random.best_params_}')
print(f'Best score: {random.best_score_}')
Best parameters: {'C': 530.8767414437036, 'gamma': 0.9699098521619943, 'kernel': 'rbf'}
Best score: 0.9506172839506174

Autres alternatives

En général,Les méthodes décrites ci - dessus sont les plus populaires et les plus couramment utilisées.Mais,Si le schéma décrit ci - dessus ne vous convient pas,Vous pouvez également envisager plusieurs alternatives.L'un d'entre eux est l'optimisation de la valeur hyperparamétrique basée sur le gradient.La technique calculera le gradient autour des hyperparamètres,Il est ensuite optimisé à l'aide d'un algorithme de descente par Gradient.Le problème avec cette approche est que,Pour que le processus de descente en gradient fonctionne correctement,Nous avons besoin de fonctions convexes et lisses,Mais il n'y a pas toujours de telles conditions dans ce domaine.Une autre approche consiste à utiliser des algorithmes évolutifs pour optimiser.

Petit  Noeud

Dans cet article,Nous présentons plusieurs algorithmes bien connus d'optimisation et de réglage des hyperparamètres.Nous avons appris à utiliser la recherche par grille、Recherche aléatoire et optimisation bayésienne pour obtenir la meilleure valeur pour les hyperparamètres.Nous avons aussi appris à utiliser Sci-KitLearn Les classes et les méthodes le font en Code.

Merci de lire!

Lien vers le texte original:

https://rubikscode.net/2021/08/17/ml-optimization-pt-3-hyperparameter-optimization-with-python/


 

版权声明
本文为[Communauté des sages]所创,转载请带上原文链接,感谢
https://pythonmana.com/2021/10/20211029181821272b.html

  1. 刚学Python,想让大大给我解释一下代码
  2. 剛學Python,想讓大大給我解釋一下代碼
  3. Je viens d'apprendre Python et je veux que tu m'expliques le Code.
  4. Python QT GUI Design: qmainwindow, QWidget and qdialog window classes (Fundamentals - 10)
  5. Python爬虫项目实战:快手网页版滑块captchaSession分析
  6. python计算时间十二小时制
  7. Temps de calcul Python 12 heures
  8. Python crawler Project actual Fighting: faster Web Version Slider CAPTCHA session Analysis
  9. Python要学习多久可以掌握?多久可以精通?
  10. Combien de temps Python va - t - il apprendre à maîtriser? Combien de temps faut - il pour maîtriser?
  11. 从官网上下载的python安装包安装不了
  12. 深度学习项目:如何使用Python和OpenCV进行人脸识别
  13. python编辑语言如内容所示
  14. La langue d'édition Python est affichée dans le contenu
  15. 有谁知道这怎么回事嘛(Python的简单代码)
  16. 有誰知道這怎麼回事嘛(Python的簡單代碼)
  17. Qui sait ce qui se passe?
  18. Python求某个数的因数【因数是指能被这个数整除的数。例如6的因数有:1、2、3、6; 7的因数有:1、7; 8的因数有:1、2、4、8】。
  19. Python calcule les facteurs d'un nombre [les facteurs sont des nombres qui peuvent être divisés par ce nombre. Par exemple, les facteurs de 6 sont: 1, 2, 3, 6; les facteurs de 7 sont: 1, 7; et les facteurs de 8 sont: 1, 2, 4, 8].
  20. 请问这个实验如何做(用python3.x的环境)
  21. 如何创建一个python程序来模拟电影院的座位预订
  22. [algorithm learning] 1486. Array XOR operation (Java / C / C + + / Python / go / trust)
  23. Comment créer un programme Python pour simuler la réservation de sièges dans un cinéma
  24. Comment faire cette expérience (en utilisant l'environnement Python 3.x)
  25. Python之绘制多角星
  26. Pandas的SettingWithCopyWarning报警怎么解决
  27. Comment résoudre l'alarme de réglage avec copywarning de pandas
  28. 使用 Python 进行数据可视化之Matplotlib
  29. Python 常见问题 - 使用 poetry build 打包构建失败,报 ModuleOrPackageNotFound No file/folder found for package
  30. 万圣节奇妙夜,不给糖就捣蛋—Python带你点击解锁恐怖新道具(南瓜头、骷髅、蝙蝠、糖......)
  31. 【算法学习】1221. 分割平衡字符串(java / c / c++ / python / go / rust)
  32. 教你用Python 编写 Hadoop MapReduce 程序
  33. Je t'ai appris à écrire Hadoop mapreduce en Python.
  34. Pandas下载最新版和python不匹配
  35. python tkinter GUI编程如何实现一个时钟,无论主线程怎么卡住,都不影响时钟正常进行走时间。
  36. python tkinter GUI編程如何實現一個時鐘,無論主線程怎麼卡住,都不影響時鐘正常進行走時間。
  37. La programmation de l'interface graphique Python tkinter pour implémenter une horloge n'affecte pas le temps de fonctionnement normal de l'horloge, peu importe comment le fil principal est coincé.
  38. Pandas télécharger la dernière version ne correspond pas à Python
  39. Make a cool music player with Python [V3.0 including source code and packaged exe]
  40. 编写一个函数,可以传入两个实参或三个实参。如果传入两个实参,返回求和。如果传入三个实参,返回的话。前两个实参的和对第三个实参求余的结果Python
  41. python用tcp写server传输文件遇到的问题
  42. Python - - fichiers et exceptions
  43. Python failed to install pyinstaller, preparing wheel metadata... Error
  44. Python Turtle库 画魔法少女里的小圆晓美焰
  45. Quels sont les types de données intégrés de python? Les chiffres.
  46. python代碼實現掃碼關注公眾號登錄
  47. Mise en œuvre du Code Python
  48. 捋一捋Python中的数学运算math库(上篇)
  49. Python:晚上把附近的足浴店都给爬了一遍,好兄弟真不错
  50. python接收字符串,返回其中字符的最后一次出现,并顺序存入列表
  51. python post请求特殊data数据怎么发送
  52. Python: J'ai escaladé tous les salons de foot voisins la nuit. C'est un bon frère.
  53. Retouchez la Bibliothèque math ématiques en Python (Partie 1)
  54. 拓端tecdat:Python 用ARIMA、GARCH模型预测分析股票市场收益率时间序列
  55. 拓端tecdat|PYTHON贝叶斯推断计算:用BETA先验分布推断概率和可视化案例
  56. Extension tedat | Python Bayesian Inference Calculation: Inference Probability and Visualization Case Using Beta precedent distribution
  57. python字典里的键是不可变类型,值是可变类型对不对
  58. Extension tedat: Python Prediction and Analysis of Stock Market return time series Using Arima and GARCH Models
  59. Python小白福音!Github开源了一款神器....
  60. Python LITTLE WHITE Gospel! Github a ouvert un artefact...