C'est bien de tracer le graphe de fonction sur un notebook jupyter avec matplotlib, mais c'est ennuyeux de changer la valeur et d'appuyer sur Ctrl + Entrée à chaque fois que vous essayez de faire une erreur. Il est courant de vouloir refléter dynamiquement les changements de prix dans les résultats avec le réactif (ancien?) - Comme la tendance qui est populaire ces jours-ci. Quand je l'ai cherché, il semble qu'une bibliothèque appelée ipywidgets ait été développée pour jupyter notebook, j'ai donc décidé de l'utiliser.

https://github.com/ipython/ipywidgets

Il semble également permettre un comportement interactif via des composants d'interface utilisateur tels que des curseurs et des zones de texte.

environnement

Je l'ai essayé dans l'environnement suivant.

OS X El Capitan
Python3.6 with venv
fish shell

Préparation

Tout d'abord, créez un environnement virtuel avec venv. Si vous êtes une personne virtualenv ou une personne bash, veuillez lire ce qui convient.

$ python3 -m venv ipywidgets_env
$ source ipywidgets_env/bin/activate.fish #Pour les poissons

Installation

Installez jupyter normalement.

(ipywidgets_env) $ pip install jupyter

Confirmez légèrement que ipywidgets est venu ensemble en tant que dépendance. Si vous ne l'avez pas, vous pouvez simplement le mettre avec pip install.

(ipywidgets_env) $ pip list | grep ipywidgets
ipywidgets (5.2.2)

En outre, exécutez la commande suivante pour jupyter pour activer la fonction d'extension de dessin.

(ipywidgets_env) $ jupyter nbextension enable --py widgetsnbextension --sys-prefix

Vérification du comportement

Maintenant que l'environnement est prêt à essayer ipywidgets, je vais l'essayer sur le notebook jupyter.

(ipywidgets_env) $ jupyter notebook

Après le démarrage, créez un nouveau cahier dans le navigateur ouvert et écrivez une fonction qui renvoie le résultat du calcul «a * x + b» dans une nouvelle cellule.

def f(x, a, b):
    return a * x + b

Pour utiliser les paramètres de cette fonction avec le composant UI du curseur, définissez la fonction ci-dessus «f» et les plages de valeurs respectives des paramètres «x», «a» et «b» sur la fonction «interagir» comme indiqué ci-dessous. Je te le donnerai.

from ipywidgets import interact
interact(f, x=(-10,10, 1), a=(-10,10, 1), b=(-10,10, 1))

Le résultat de l'exécution sur le navigateur est le suivant.

Un curseur est apparu sur l'écran. Jouez avec les boutons.

Initialement x = 0, a = 0, b = 0 et le résultat était 0, mais si vous définissez x = 10, a = 4, b = -10, il sera immédiatement reflété dans le résultat comme 30 Est affiché. De cette manière, nous avons pu confirmer la réflexion dynamique de la valeur par ipywigdets.

Refléter le résultat en ajustant le seuil de binarisation de l'image avec le curseur

En tant que petite application, je voudrais essayer de refléter le seuil de binarisation, qui est un traitement d'image standard, dans le résultat tout en le faisant fonctionner moi-même. J'utilise ma propre image d'icône.

Pour le moment, j'utiliserai Pillow, un outil de traitement d'image en Python. Si vous l'avez déjà installé, vous n'avez pas besoin d'exécuter la commande suivante.

(ipywidgets_env) $ pip install Pillow

Tout d'abord, importez Pillow et chargez l'image de gradation 255 de Greske dans la variable globale ʻimg`.

from PIL import Image
img = Image.open('picture.jpeg').convert('L')

@interact
def binarize(th: (0, 255, 1)):
    return img.point(lambda p: 255 if p > th else 0)

Vous pouvez également utiliser ipywidgets en définissant une fonction binarize qui est dynamiquement actionnée par ipywidgets, en créant une fonction qui renvoie l'image après la binarisation par la variable de seuil th, et en ajoutant un décorateur ʻinteract`. pouvez. Lorsque vous exécutez la cellule ci-dessus,

De cette manière, vous pouvez effectuer une binarisation dynamique tout en déplaçant le curseur de seuil sur le notebook jupyter.

Au fait, je vais essayer le diff d'image de GitHub

Maintenant que je sais comment utiliser le curseur, je vais essayer d'imiter la célèbre méthode de confirmation de différence d'image GitHub. Je ne connaissais pas très bien Pillow et ne savais pas comment régler la saturation d'une image partielle, alors j'ai fini par le faire en vain pour superposer l'image par-dessus.

orig = Image.open('picture.jpeg')

@interact
def github_diff(percentage: (0, 100, 1)):
    orig_copied = orig.copy()
    box = (int(img.width / 100 * percentage), 0, img.width, img.height)
    img_cropped = img.crop(box)
    orig_copied.paste(img_cropped, box)
    return orig_copied

Après avoir chargé l'image originale dans ʻorig, l'image originale est affichée dynamiquement sur le côté gauche et l'image Gresque est dessinée sur le côté droit en fonction du rapport spécifié par le curseur. paste` semble être une méthode destructrice, prenant une copie de l'image originale pour chaque changement de valeur. Je voudrais savoir s'il existe une meilleure façon.

Résumé

Le notebook jupyter, déjà adapté à l'expérimentation et à la vérification, sera encore plus simple d'utilisation!

Utilisez ipywidgets dans jupyter notebook pour manipuler les paramètres de manière interactive, puis essayez le traitement d'image