Pythonでベイジアンネットワークを作る際に出たエラー

'utf-8' codec can't decode byte 0x91 in position 0: invalid start byte

import pymc3 as pm

import cv2
import numpy as np
import pymc3 as pm
import theano.tensor as tt
import pandas as pd


# 画像ファイルを読み込む
image_path =r"C:\Users\ryotn\Documents\Python\changed_45_0.02\1\edge.jpg"
image = cv2.imread(image_path)


# 画像をグレースケールに変換する
img_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

# ラプラシアン値を計算する
laplacian_value = cv2.Laplacian(img_gray, cv2.CV_64F).var()

# PSNRを計算する関数を実装する
def calculate_psnr(original_image, degraded_image):
    mse = np.mean((original_image - degraded_image) ** 2)
    psnr = 10 * np.log10(255**2 / mse)
    return psnr

# エッジ密度を計算する関数を実装する
def calculate_edge_density(image):
    # 画像をグレースケールに変換する
    img_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    # Cannyエッジ検出を適用する
    edges = cv2.Canny(img_gray, threshold1=100, threshold2=200)  # 適切な閾値を選択してください

    # エッジ密度を計算する
    edge_density_value = np.count_nonzero(edges) / (img_gray.shape[0] * img_gray.shape[1])

    return edge_density_value

# コントラスト値を計算する関数を実装する
def calculate_contrast(image):
    # 画像をグレースケールに変換する
    img_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)

    # ヒストグラムの平坦化を行う
    img_eq = cv2.equalizeHist(img_gray)

    # コントラスト値を計算する
    contrast_value = np.std(img_eq)

    return contrast_value

# PSNR、エッジ密度、コントラスト値を計算
# ノイズの付加
def add_noise(image, noise_type='gaussian', mean=0, stddev=50):
    if noise_type == 'gaussian':
        noise = np.random.normal(mean, stddev, image.shape)
    elif noise_type == 'salt_and_pepper':
        noise = np.random.choice([0, 255], size=image.shape, p=[0.05, 0.05])
    else:
        raise ValueError("Invalid noise_type. Should be 'gaussian' or 'salt_and_pepper'.")

    noisy_image = np.clip(image + noise, 0, 255).astype(np.uint8)
    return noisy_image

degraded_image = add_noise(image, noise_type='gaussian', mean=0, stddev=50)

# 画像の解像度を低下させる
def downsample_image(image, scale_factor=2):
    h, w = image.shape[:2]
    new_h, new_w = h // scale_factor, w // scale_factor
    downsampled_image = cv2.resize(image, (new_w, new_h))
    return downsampled_image

degraded_image = downsample_image(image, scale_factor=2)
psnr_value = calculate_psnr(img_gray, degraded_image)
edge_density_value = calculate_edge_density(image)
contrast_value = calculate_contrast(image)

# ハイパス フィルタ
kernel_high_pass = np.array([
    [-1, -1, -1],
    [-1,  8, -1],
    [-1, -1, -1]
], np.float32)

# ハイパスフィルタを適用
degraded_high_pass = cv2.filter2D(degraded_image, -1, kernel_high_pass)

#上記のもので画像を劣化させている

# 特徴ベクトルを作成する
feature_vector = np.array([laplacian_value, psnr_value, edge_density_value, contrast_value])

# CSVファイルからデータを読み込む
data = pd.read_csv('data.csv', encoding='shift_jis')

# ラベル（良い画像: 1, 劣化画像: 0）を用意
labels = np.array([1, 0])  # 各画像のラベルを適切に設定する

# ベイジアンネットワークの構築
with pm.Model() as model:
    # 特徴ベクトルの事前分布を設定
    features = pm.Data("features", feature_vector)

    # パラメータの事前分布を設定
    # ラプラシアン値の事前分布を設定（ガウス分布）
    laplacian_mean = pm.Normal("laplacian_mean", mu=0.0, sigma=1.0)
    laplacian_std = pm.HalfNormal("laplacian_std", sigma=1.0)
    laplacian_prior = pm.Normal("laplacian_prior", mu=laplacian_mean, sigma=laplacian_std)

    # PSNRの事前分布を設定（ガンマ分布）
    psnr_shape = pm.HalfNormal("psnr_shape", sigma=2.0)
    psnr_scale = pm.HalfNormal("psnr_scale", sigma=1.0)
    psnr_prior = pm.Gamma("psnr_prior", alpha=psnr_shape, beta=psnr_scale)

    # エッジ密度の事前分布を設定（ベータ分布）
    edge_density_alpha = pm.HalfNormal("edge_density_alpha", sigma=2.0)
    edge_density_beta = pm.HalfNormal("edge_density_beta", sigma=5.0)
    edge_density_prior = pm.Beta("edge_density_prior", alpha=edge_density_alpha, beta=edge_density_beta)

    # コントラスト値の事前分布を設定（指数分布）
    contrast_lambda = pm.HalfNormal("contrast_lambda", sigma=0.5)
    contrast_prior = pm.Exponential("contrast_prior", lam=contrast_lambda)

    # ロジスティック回帰を定義
    theta = pm.Normal("theta", mu=0, sigma=1, shape=4)
    logits = tt.dot(features, theta)
    p = pm.Deterministic("p", 1 / (1 + tt.exp(-logits)))

    # ラベルの観測を設定
    y = pm.Bernoulli("y", p=p, observed=labels)

    # モデルの学習
    trace = pm.sample(2000, tune=1000)

# 新しい画像に対して良否判定を行う
new_image_path = "path/to/new_image.jpg"
new_image = cv2.imread(new_image_path)


# 新しい画像をグレースケールに変換する
new_img_gray = cv2.cvtColor(new_image, cv2.COLOR_BGR2GRAY)

# 新しい画像に対してラプラシアン値を計算する
new_laplacian_value = cv2.Laplacian(new_img_gray, cv2.CV_64F).var()

# 新しい画像のPSNRを計算する
new_psnr_value = calculate_psnr(new_img_gray, new_image)

# 新しい画像のエッジ密度を計算する
new_edge_density_value = calculate_edge_density(new_image)

# 新しい画像のコントラスト値を計算する
new_contrast_value = calculate_contrast(new_image)

# 新しい特徴ベクトルを作成
new_feature_vector = np.array([new_laplacian_value, new_psnr_value, new_edge_density_value, new_contrast_value])

# ベイジアンネットワークによる良否判定
with model:
    pm.set_data({"features": new_feature_vector})
    post_pred = pm.sample_posterior_predictive(trace)
    predicted_labels = post_pred["y"].mean(axis=0)

# 良否判定結果を表示
if predicted_labels[0] > 0.5:
    print("The new image is classified as GOOD.")
else:
    print("The new image is classified as BAD.")