import seaborn as sns
import pandas as pd
df = pd.DataFrame(np.random.randn(100, 4), columns=['A', 'B', 'C', 'D'])
# sns.pairplot(df) # This line would generate the plot
print("Output: A figure grid opens showing scatterplots for each pair of variables.")

Output: A figure grid opens showing scatterplots for each pair of variables.

#88. sns.countplot()
Shows the counts of observations in each categorical bin using bars.

import seaborn as sns
import pandas as pd
df = pd.DataFrame({'category': ['A', 'B', 'A', 'C', 'A', 'B']})
sns.countplot(x='category', data=df)
print("Output: A figure window opens showing a count plot.")

Output: A figure window opens showing a count plot.

#89. sns.jointplot()
Draws a plot of two variables with bivariate and univariate graphs.

import seaborn as sns
import pandas as pd
df = pd.DataFrame({'x': range(50), 'y': range(50) + np.random.randn(50)})
# sns.jointplot(x='x', y='y', data=df) # This line would generate the plot
print("Output: A figure shows a scatter plot with histograms for each axis.")

Output: A figure shows a scatter plot with histograms for each axis.

#90. plt.show()
Displays all open figures.

import matplotlib.pyplot as plt
plt.plot([1, 2, 3])
# plt.show() # In a script, this is essential to see the plot.
print("Executes the command to render and display the plot.")

Executes the command to render and display the plot.

---
#DataAnalysis #ScikitLearn #Modeling #Preprocessing

Part 9: Scikit-learn - Modeling & Preprocessing

#91. train_test_split()
Splits arrays or matrices into random train and test subsets.

from sklearn.model_selection import train_test_split
import numpy as np
X, y = np.arange(10).reshape((5, 2)), range(5)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.33)
print(f"X_train shape: {X_train.shape}")
print(f"X_test shape: {X_test.shape}")

X_train shape: (3, 2)
X_test shape: (2, 2)

#92. StandardScaler()
Standardizes features by removing the mean and scaling to unit variance.

from sklearn.preprocessing import StandardScaler
data = [[0, 0], [0, 0], [1, 1], [1, 1]]
scaler = StandardScaler()
print(scaler.fit_transform(data))

[[-1. -1.]
 [-1. -1.]
 [ 1.  1.]
 [ 1.  1.]]

#93. MinMaxScaler()
Transforms features by scaling each feature to a given range, typically [0, 1].

from sklearn.preprocessing import MinMaxScaler
data = [[-1, 2], [-0.5, 6], [0, 10], [1, 18]]
scaler = MinMaxScaler()
print(scaler.fit_transform(data))

[[0.   0.  ]
 [0.25 0.25]
 [0.5  0.5 ]
 [1.   1.  ]]

#94. LabelEncoder()
Encodes target labels with values between 0 and n_classes-1.

from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
encoded = le.fit_transform(['paris', 'tokyo', 'paris'])
print(encoded)

[0 1 0]

#95. OneHotEncoder()
Encodes categorical features as a one-hot numeric array.

from sklearn.preprocessing import OneHotEncoder
enc = OneHotEncoder()
X = [['Male'], ['Female'], ['Female']]
print(enc.fit_transform(X).toarray())

[[0. 1.]
 [1. 0.]
 [1. 0.]]

#96. LinearRegression()
Ordinary least squares Linear Regression model.

from sklearn.linear_model import LinearRegression
X = [[0], [1], [2]]
y = [0, 1, 2]
reg = LinearRegression().fit(X, y)
print(f"Coefficient: {reg.coef_[0]}")

Coefficient: 1.0

#97. LogisticRegression()
Implements Logistic Regression for classification.

from sklearn.linear_model import LogisticRegression
X = [[-1], [0], [1], [2]]
y = [0, 0, 1, 1]
clf = LogisticRegression().fit(X, y)
print(f"Prediction for [[-2]]: {clf.predict([[-2]])}")

Prediction for [[-2]]: [0]

#98. KMeans()
K-Means clustering algorithm.

from sklearn.cluster import KMeans
X = [[1, 2], [1, 4], [1, 0], [10, 2], [10, 4], [10, 0]]
kmeans = KMeans(n_clusters=2, n_init='auto').fit(X)
print(kmeans.labels_)

[0 0 0 1 1 1]
(Note: Cluster labels may be flipped, e.g., [1 1 1 0 0 0])

#99. accuracy_score()
Calculates the accuracy classification score.

from sklearn.metrics import accuracy_score
y_true = [0, 1, 1, 0]
y_pred = [0, 1, 0, 0]
print(accuracy_score(y_true, y_pred))

0.75

#100. confusion_matrix()
Computes a confusion matrix to evaluate the accuracy of a classification.

from sklearn.metrics import confusion_matrix
y_true = [0, 1, 0, 1]
y_pred = [1, 1, 0, 1]
print(confusion_matrix(y_true, y_pred))

[[1 1]
 [0 2]]

━━━━━━━━━━━━━━━
By: @CodeProgrammer ✨

Do you like such lessons?

💡 Top 50 Pillow Operations for Image Processing

I. File & Basic Operations

• Open an image file.

from PIL import Image
img = Image.open("image.jpg")

• Save an image.

img.save("new_image.png")

• Display an image (opens in default viewer).

img.show()

• Create a new blank image.

new_img = Image.new("RGB", (200, 100), "blue")

• Get image format (e.g., 'JPEG').

print(img.format)

• Get image dimensions as a (width, height) tuple.

width, height = img.size

• Get pixel format (e.g., 'RGB', 'L' for grayscale).

print(img.mode)

• Convert image mode.

grayscale_img = img.convert("L")

• Get a pixel's color value at (x, y).

r, g, b = img.getpixel((10, 20))

• Set a pixel's color value at (x, y).

img.putpixel((10, 20), (255, 0, 0))

II. Cropping, Resizing & Pasting

• Crop a rectangular region.

box = (100, 100, 400, 400)
cropped_img = img.crop(box)

• Resize an image to an exact size.

resized_img = img.resize((200, 200))

• Create a thumbnail (maintains aspect ratio).

img.thumbnail((128, 128))

• Paste one image onto another.

img.paste(another_img, (50, 50))

III. Rotation & Transformation

• Rotate an image (counter-clockwise).

rotated_img = img.rotate(45, expand=True)

• Flip an image horizontally.

flipped_img = img.transpose(Image.FLIP_LEFT_RIGHT)

• Flip an image vertically.

flipped_img = img.transpose(Image.FLIP_TOP_BOTTOM)

• Rotate by 90, 180, or 270 degrees.

img_90 = img.transpose(Image.ROTATE_90)

• Apply an affine transformation.

transformed = img.transform(img.size, Image.AFFINE, (1, 0.5, 0, 0, 1, 0))

IV. ImageOps Module Helpers

• Invert image colors.

from PIL import ImageOps
inverted_img = ImageOps.invert(img)

• Flip an image horizontally (mirror).

mirrored_img = ImageOps.mirror(img)

• Flip an image vertically.

flipped_v_img = ImageOps.flip(img)

• Convert to grayscale.

grayscale = ImageOps.grayscale(img)

• Colorize a grayscale image.

colorized = ImageOps.colorize(grayscale, black="blue", white="yellow")

• Reduce the number of bits for each color channel.

posterized = ImageOps.posterize(img, 4)

• Auto-adjust image contrast.

adjusted_img = ImageOps.autocontrast(img)

• Equalize the image histogram.

equalized_img = ImageOps.equalize(img)

• Add a border to an image.

bordered = ImageOps.expand(img, border=10, fill='black')

V. Color & Pixel Operations

• Split image into individual bands (e.g., R, G, B).

r, g, b = img.split()

• Merge bands back into an image.

merged_img = Image.merge("RGB", (r, g, b))

• Apply a function to each pixel.

brighter_img = img.point(lambda i: i * 1.2)

• Get a list of colors used in the image.

colors = img.getcolors(maxcolors=256)

• Blend two images with alpha compositing.

# Both images must be in RGBA mode
blended = Image.alpha_composite(img1_rgba, img2_rgba)

VI. Filters (ImageFilter)

• Apply a simple blur filter.

from PIL import ImageFilter
blurred_img = img.filter(ImageFilter.BLUR)

• Apply a box blur with a given radius.

box_blur = img.filter(ImageFilter.BoxBlur(5))

• Apply a Gaussian blur.

gaussian_blur = img.filter(ImageFilter.GaussianBlur(radius=2))

• Sharpen the image.

sharpened = img.filter(ImageFilter.SHARPEN)

• Find edges.

edges = img.filter(ImageFilter.FIND_EDGES)

• Enhance edges.

edge_enhanced = img.filter(ImageFilter.EDGE_ENHANCE)

• Emboss the image.

embossed = img.filter(ImageFilter.EMBOSS)

• Find contours.

contours = img.filter(ImageFilter.CONTOUR)

VII. Image Enhancement (ImageEnhance)

• Adjust color saturation.

from PIL import ImageEnhance
enhancer = ImageEnhance.Color(img)
vibrant_img = enhancer.enhance(2.0)

• Adjust brightness.

enhancer = ImageEnhance.Brightness(img)
bright_img = enhancer.enhance(1.5)

• Adjust contrast.

enhancer = ImageEnhance.Contrast(img)
contrast_img = enhancer.enhance(1.5)

• Adjust sharpness.

enhancer = ImageEnhance.Sharpness(img)
sharp_img = enhancer.enhance(2.0)

VIII. Drawing (ImageDraw & ImageFont)

• Draw text on an image.

from PIL import ImageDraw, ImageFont
draw = ImageDraw.Draw(img)
font = ImageFont.truetype("arial.ttf", 36)
draw.text((10, 10), "Hello", font=font, fill="red")

• Draw a line.

draw.line((0, 0, 100, 200), fill="blue", width=3)

• Draw a rectangle (outline).

draw.rectangle([10, 10, 90, 60], outline="green", width=2)

• Draw a filled ellipse.

draw.ellipse([100, 100, 180, 150], fill="yellow")

• Draw a polygon.

draw.polygon([(10,10), (20,50), (60,10)], fill="purple")

#Python #Pillow #ImageProcessing #PIL #CheatSheet

━━━━━━━━━━━━━━━
By: @CodeProgrammer ✨