10 praktische Fälle der Python-Data-Science-Bibliothek (mit Code)

Damit jeder ein vorläufiges Verständnis der Python-Bibliotheken hat, die üblicherweise in der künstlichen Intelligenz verwendet werden, um eine Bibliothek auszuwählen, die seinen Lernbedürfnissen entspricht, wird eine kurze und umfassende Einführung in die gebräuchlicheren Bibliotheken für künstliche Intelligenz gegeben.

1. Numpy

NumPy(Numerical Python)Es ist  Pythoneine erweiterte Programmbibliothek, die eine große Anzahl von dimensionalen Arrays und Matrixoperationen unterstützt. Darüber hinaus bietet sie auch eine große Anzahl von mathematischen Funktionsbibliotheken für Array-Operationen. Die zugrunde liegende Verwendung wird geschrieben. Objekte werden direkt im Array Numpygespeichert C语言, statt Objektzeiger, so dass die Betriebseffizienz viel höher ist.Yu- 纯Python代Code. 纯PythonWir können die Geschwindigkeit mit der Berechnung des Sinuswertes der Liste im Beispiel vergleichen Numpy库:

import numpy as np
import math
import random
import time

start = time.time()
for i in range(10):
    list_1 = list(range(1,10000))
    for j in range(len(list_1)):
        list_1[j] = math.sin(list_1[j])
print("使用纯Python用时{}s".format(time.time()-start))

start = time.time()
for i in range(10):
    list_1 = np.array(np.arange(1,10000))
    list_1 = np.sin(list_1)
print("使用Numpy用时{}s".format(time.time()-start))

Aus den folgenden Laufergebnissen können Sie ersehen, dass die Verwendung  Numpy der Bibliothek schneller ist als Code, der in reinem Python geschrieben wurde:

0,017444372177124023s mit reinem Python und
0,001619577407836914s mit Numpy

2. OpenCV

OpenCV ist eine plattformübergreifende Computer-Vision-Bibliothek, die auf den Betriebssystemen Linux, Windows und Mac OS ausgeführt werden kann. Es ist leicht und effizient – ​​es besteht aus einer Reihe von C-Funktionen und einer Handvoll C++-Klassen und bietet außerdem  Python Schnittstellen, die viele gängige Algorithmen in der Bildverarbeitung und Computer Vision implementieren. Der folgende Code versucht, einige einfache Filter zu verwenden, einschließlich Bildglättung, Gaußscher Weichzeichner usw.: 

import numpy as np
import cv2 as cv
from matplotlib import pyplot as plt
img = cv.imread('h89817032p0.png')
kernel = np.ones((5,5),np.float32)/25
dst = cv.filter2D(img,-1,kernel)
blur_1 = cv.GaussianBlur(img,(5,5),0)
blur_2 = cv.bilateralFilter(img,9,75,75)
plt.figure(figsize=(10,10))
plt.subplot(221),plt.imshow(img[:,:,::-1]),plt.title('Original')
plt.xticks([]), plt.yticks([])
plt.subplot(222),plt.imshow(dst[:,:,::-1]),plt.title('Averaging')
plt.xticks([]), plt.yticks([])
plt.subplot(223),plt.imshow(blur_1[:,:,::-1]),plt.title('Gaussian')
plt.xticks([]), plt.yticks([])
plt.subplot(224),plt.imshow(blur_1[:,:,::-1]),plt.title('Bilateral')
plt.xticks([]), plt.yticks([])
plt.show()

 

3、Scikit-Bild

scikit-imageist scipyeine Bildverarbeitungsbibliothek basierend auf , die numpyBilder als Arrays verarbeitet. Beispielsweise können Sie mit scikit-imageden Bildmaßstab ändern und Funktionen wie , und scikit-imagebereitstellen . rescaleresizedownscale_local_mean

from skimage import data, color, io
from skimage.transform import rescale, resize, downscale_local_mean

image = color.rgb2gray(io.imread('h89817032p0.png'))

image_rescaled = rescale(image, 0.25, anti_aliasing=False)
image_resized = resize(image, (image.shape[0] // 4, image.shape[1] // 4),
                       anti_aliasing=True)
image_downscaled = downscale_local_mean(image, (4, 3))
plt.figure(figsize=(20,20))
plt.subplot(221),plt.imshow(image, cmap='gray'),plt.title('Original')
plt.xticks([]), plt.yticks([])
plt.subplot(222),plt.imshow(image_rescaled, cmap='gray'),plt.title('Rescaled')
plt.xticks([]), plt.yticks([])
plt.subplot(223),plt.imshow(image_resized, cmap='gray'),plt.title('Resized')
plt.xticks([]), plt.yticks([])
plt.subplot(224),plt.imshow(image_downscaled, cmap='gray'),plt.title('Downscaled')
plt.xticks([]), plt.yticks([])
plt.show()

4. PIL

Python Imaging Library(PIL)Python Sie ist de facto zur Standardbibliothek für die Bildverarbeitung  geworden  , da PIL die Funktion sehr leistungsfähig ist, die API jedoch sehr einfach und leicht zu bedienen ist. Da PIL jedoch nur bis zu 1 unterstützt  und seit langem marode ist  ,  hat  eine kompatible Version auf Basis von .use erstellt Python 2.7eine Gruppe von Freiwilligen  .PILPillowPython 3.xPILPillow

5. Kissen

Pillow Erstellen Sie Buchstaben-Captcha-Bilder mit  :

from PIL import Image, ImageDraw, ImageFont, ImageFilter

import random

# 随机字母:
def rndChar():
    return chr(random.randint(65, 90))

# 随机颜色1:
def rndColor():
    return (random.randint(64, 255), random.randint(64, 255), random.randint(64, 255))

# 随机颜色2:
def rndColor2():
    return (random.randint(32, 127), random.randint(32, 127), random.randint(32, 127))

# 240 x 60:
width = 60 * 6
height = 60 * 6
image = Image.new('RGB', (width, height), (255, 255, 255))
# 创建Font对象:
font = ImageFont.truetype('/usr/share/fonts/wps-office/simhei.ttf', 60)
# 创建Draw对象:
draw = ImageDraw.Draw(image)
# 填充每个像素:
for x in range(width):
    for y in range(height):
        draw.point((x, y), fill=rndColor())
# 输出文字:
for t in range(6):
    draw.text((60 * t + 10, 150), rndChar(), font=font, fill=rndColor2())
# 模糊:
image = image.filter(ImageFilter.BLUR)
image.save('code.jpg', 'jpeg')

 

 

6. Einfacher Lebenslauf

SimpleCV ist ein Open-Source-Framework zum Erstellen von Computer-Vision-Anwendungen. Damit können Sie auf leistungsstarke Computer-Vision-Bibliotheken wie OpenCV zugreifen, ohne sich erst mit Begriffen wie Bittiefe, Dateiformat, Farbraum, Pufferverwaltung, Eigenwerten oder Matrizen vertraut machen zu müssen. Aber die Unterstützung für Python3 ist sehr schlecht, verwenden Sie den folgenden Code in Python3.7: 

 

from SimpleCV import Image, Color, Display
# load an image from imgur
img = Image('http://i.imgur.com/lfAeZ4n.png')
# use a keypoint detector to find areas of interest
feats = img.findKeypoints()
# draw the list of keypoints
feats.draw(color=Color.RED)
# show the  resulting image. 
img.show()
# apply the stuff we found to the image.
output = img.applyLayers()
# save the results.
output.save('juniperfeats.png')

Der folgende Fehler wird gemeldet, daher wird  Python3 seine Verwendung nicht empfohlen in: 

SyntaxError: Missing parentheses in call to 'print'. Did you mean print('unit test')?

7. Mahotas

Mahotas ist eine darauf aufbauende Bibliothek schneller Computer-Vision-Algorithmen  Numpy , die derzeit über 100 Bildverarbeitungs- und Computer-Vision-Funktionen umfasst und wächst. Laden Sie das Bild mit  Mahotas und bearbeiten Sie die Pixel

 

import numpy as np
import mahotas
import mahotas.demos

from mahotas.thresholding import soft_threshold
from matplotlib import pyplot as plt
from os import path
f = mahotas.demos.load('lena', as_grey=True)
f = f[128:,128:]
plt.gray()
# Show the data:
print("Fraction of zeros in original image: {0}".format(np.mean(f==0)))
plt.imshow(f)
plt.show()

8. Elastisch

Ilastik Es kann Benutzern gute auf maschinellem Lernen basierende Bioinformatik-Bildanalysedienste bieten, die maschinelle Lernalgorithmen verwenden, um Zellen oder andere experimentelle Daten einfach zu segmentieren, zu klassifizieren, zu verfolgen und zu zählen. Die meisten Vorgänge sind interaktiv und erfordern keine maschinellen Lernkenntnisse.

9. Scikit-Lernen 

Scikit-learn ist  Python eine Freeware-Bibliothek für maschinelles Lernen für Programmiersprachen. Es verfügt über eine Vielzahl von Klassifizierungs-, Regressions- und Clustering-Algorithmen, darunter Support Vector Machines, Random Forests, Gradient Boosting, k-Means und DBSCAN und viele andere Algorithmen für maschinelles Lernen. Scikit-learnImplementieren Sie den Algorithmus mit KMeans:

 

import time

import numpy as np
import matplotlib.pyplot as plt

from sklearn.cluster import MiniBatchKMeans, KMeans
from sklearn.metrics.pairwise import pairwise_distances_argmin
from sklearn.datasets import make_blobs

# Generate sample data
np.random.seed(0)

batch_size = 45
centers = [[1, 1], [-1, -1], [1, -1]]
n_clusters = len(centers)
X, labels_true = make_blobs(n_samples=3000, centers=centers, cluster_std=0.7)

# Compute clustering with Means

k_means = KMeans(init='k-means++', n_clusters=3, n_init=10)
t0 = time.time()
k_means.fit(X)
t_batch = time.time() - t0

# Compute clustering with MiniBatchKMeans

mbk = MiniBatchKMeans(init='k-means++', n_clusters=3, batch_size=batch_size,
                      n_init=10, max_no_improvement=10, verbose=0)
t0 = time.time()
mbk.fit(X)
t_mini_batch = time.time() - t0

# Plot result
fig = plt.figure(figsize=(8, 3))
fig.subplots_adjust(left=0.02, right=0.98, bottom=0.05, top=0.9)
colors = ['#4EACC5', '#FF9C34', '#4E9A06']

# We want to have the same colors for the same cluster from the
# MiniBatchKMeans and the KMeans algorithm. Let's pair the cluster centers per
# closest one.
k_means_cluster_centers = k_means.cluster_centers_
order = pairwise_distances_argmin(k_means.cluster_centers_,
                                  mbk.cluster_centers_)
mbk_means_cluster_centers = mbk.cluster_centers_[order]

k_means_labels = pairwise_distances_argmin(X, k_means_cluster_centers)
mbk_means_labels = pairwise_distances_argmin(X, mbk_means_cluster_centers)

# KMeans
for k, col in zip(range(n_clusters), colors):
    my_members = k_means_labels == k
    cluster_center = k_means_cluster_centers[k]
    plt.plot(X[my_members, 0], X[my_members, 1], 'w',
            markerfacecolor=col, marker='.')
    plt.plot(cluster_center[0], cluster_center[1], 'o', markerfacecolor=col,
            markeredgecolor='k', markersize=6)
plt.title('KMeans')
plt.xticks(())
plt.yticks(())

plt.show()

10. SciPy

SciPy Die Bibliothek bietet viele benutzerfreundliche und effiziente numerische Berechnungen, wie z. B. numerische Integration, Interpolation, Optimierung, lineare Algebra usw. SciPy Die Bibliothek definiert viele spezielle Funktionen für die mathematische Physik, darunter elliptische Funktionen, Bessel-Funktionen, Gamma-Funktionen, Beta-Funktionen, hypergeometrische Funktionen, parabolische Zylinderfunktionen und mehr.

 

from scipy import special
import matplotlib.pyplot as plt
import numpy as np

def drumhead_height(n, k, distance, angle, t):
    kth_zero = special.jn_zeros(n, k)[-1]
    return np.cos(t) * np.cos(n*angle) * special.jn(n, distance*kth_zero)

theta = np.r_[0:2*np.pi:50j]
radius = np.r_[0:1:50j]
x = np.array([r * np.cos(theta) for r in radius])
y = np.array([r * np.sin(theta) for r in radius])
z = np.array([drumhead_height(1, 1, r, theta, 0.5) for r in radius])


fig = plt.figure()
ax = fig.add_axes(rect=(0, 0.05, 0.95, 0.95), projection='3d')
ax.plot_surface(x, y, z, rstride=1, cstride=1, cmap='RdBu_r', vmin=-0.5, vmax=0.5)
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_xticks(np.arange(-1, 1.1, 0.5))
ax.set_yticks(np.arange(-1, 1.1, 0.5))
ax.set_zlabel('Z')
plt.show()