请用python实现lsb信息隐藏算法并改进，完成上述1和2并给出代码

1. LSB信息隐藏算法实现

LSB信息隐藏算法是一种简单的信息隐藏方法，它将消息的二进制码嵌入到像素的最低有效位中，从而实现信息隐藏。以下是一个简单的Python实现：

from PIL import Image

def encode_image(image_path, secret_message):
    """将秘密消息嵌入到图像中"""
    # 打开图像文件
    image = Image.open(image_path)

    # 将秘密消息转换为二进制字符串
    binary_message = ''.join([format(ord(char), "08b") for char in secret_message])

    # 检查是否有足够的像素来嵌入消息
    if len(binary_message) > image.width * image.height:
        raise ValueError("不够的像素来嵌入消息！")

    # 将二进制消息嵌入到图像中
    encoded_image = image.copy()
    index = 0
    for x in range(image.width):
        for y in range(image.height):
            # 获取像素的RGB值
            r, g, b = image.getpixel((x, y))

            # 将消息嵌入到最低有效位
            if index < len(binary_message):
                r &= 0b11111110 | int(binary_message[index])
                index += 1
            if index < len(binary_message):
                g &= 0b11111110 | int(binary_message[index])
                index += 1
            if index < len(binary_message):
                b &= 0b11111110 | int(binary_message[index])
                index += 1

            # 更新像素值
            encoded_image.putpixel((x, y), (r, g, b))

            # 检查是否已经完成嵌入
            if index >= len(binary_message):
                return encoded_image

    return encoded_image

def decode_image(image_path):
    """从图像中提取秘密消息"""
    # 打开图像文件
    image = Image.open(image_path)

    # 从图像中提取秘密消息
    binary_message = ""
    for x in range(image.width):
        for y in range(image.height):
            # 获取像素的RGB值
            r, g, b = image.getpixel((x, y))

            # 提取最低有效位
            binary_message += str(r & 1)
            binary_message += str(g & 1)
            binary_message += str(b & 1)

            # 检查是否已经提取完整个消息
            if len(binary_message) >= 8 and binary_message[-8:] == "00000000":
                # 将二进制消息转换回字符串
                secret_message = ""
                for i in range(0, len(binary_message)-8, 8):
                    secret_message += chr(int(binary_message[i:i+8], 2))
                return secret_message

    # 如果未找到消息，则返回None
    return None

使用示例：

# 将秘密消息嵌入到图像中
encoded_image = encode_image("image.png", "Hello, world!")

# 保存嵌有秘密消息的图像
encoded_image.save("encoded_image.png")

# 从图像中提取秘密消息
secret_message = decode_image("encoded_image.png")
print(secret_message)

2. 改进的LSB信息隐藏算法实现

改进的LSB信息隐藏算法是一种更加安全的信息隐藏方法，它在嵌入信息时考虑到了像素值的分布情况，从而使得嵌入的信息更加难以被检测到。以下是一个简单的Python实现：

from PIL import Image
import numpy as np
import math

def mean_squared_error(img1, img2):
    """计算两张图像的均方误差"""
    mse = np.mean((img1 - img2) ** 2)
    return mse

def peak_signal_to_noise_ratio(img1, img2):
    """计算两张图像的峰值信噪比"""
    mse = mean_squared_error(img1, img2)
    if mse == 0:
        return float('inf')
    psnr = 20 * math.log10(255.0 / math.sqrt(mse))
    return psnr

def encode_image(image_path, secret_message, alpha=0.1):
    """将秘密消息嵌入到图像中"""
    # 打开图像文件
    image = Image.open(image_path)

    # 将秘密消息转换为二进制字符串
    binary_message = ''.join([format(ord(char), "08b") for char in secret_message])

    # 检查是否有足够的像素来嵌入消息
    if len(binary_message) > image.width * image.height:
        raise ValueError("不够的像素来嵌入消息！")

    # 将二进制消息嵌入到图像中
    encoded_image = image.copy()
    index = 0
    for x in range(image.width):
        for y in range(image.height):
            # 获取像素的RGB值
            r, g, b = image.getpixel((x, y))

            # 计算像素的分布情况
            rgb = np.array([r, g, b], dtype=np.float32)
            rgb_std = np.std(rgb)
            if rgb_std == 0:
                continue
            rgb_mean = np.mean(rgb)
            p = rgb_std / rgb_mean

            # 计算alpha值
            alpha_prime = alpha * p

            # 将消息嵌入到最低有效位
            if index < len(binary_message):
                if binary_message[index] == "0":
                    r_prime = r - alpha_prime
                    if r_prime < 0:
                        r_prime = 0
                else:
                    r_prime = r + alpha_prime
                    if r_prime > 255:
                        r_prime = 255
                index += 1
            else:
                r_prime = r

            if index < len(binary_message):
                if binary_message[index] == "0":
                    g_prime = g - alpha_prime
                    if g_prime < 0:
                        g_prime = 0
                else:
                    g_prime = g + alpha_prime
                    if g_prime > 255:
                        g_prime = 255
                index += 1
            else:
                g_prime = g

            if index < len(binary_message):
                if binary_message[index] == "0":
                    b_prime = b - alpha_prime
                    if b_prime < 0:
                        b_prime = 0
                else:
                    b_prime = b + alpha_prime
                    if b_prime > 255:
                        b_prime = 255
                index += 1
            else:
                b_prime = b

            # 更新像素值
            encoded_image.putpixel((x, y), (int(r_prime), int(g_prime), int(b_prime)))

            # 检查是否已经完成嵌入
            if index >= len(binary_message):
                return encoded_image

    return encoded_image

def decode_image(image_path, alpha=0.1):
    """从图像中提取秘密消息"""
    # 打开图像文件
    image = Image.open(image_path)

    # 从图像中提取秘密消息
    binary_message = ""
    for x in range(image.width):
        for y in range(image.height):
            # 获取像素的RGB值
            r, g, b = image.getpixel((x, y))

            # 计算像素的分布情况
            rgb = np.array([r, g, b], dtype=np.float32)
            rgb_std = np.std(rgb)
            if rgb_std == 0:
                continue
            rgb_mean = np.mean(rgb)
            p = rgb_std / rgb_mean

            # 计算alpha值
            alpha_prime = alpha * p

            # 提取最低有效位
            if abs(r - (r - alpha_prime)) > abs(r - (r + alpha_prime)):
                binary_message += "1"
            else:
                binary_message += "0"
            if abs(g - (g - alpha_prime)) > abs(g - (g + alpha_prime)):
                binary_message += "1"
            else:
                binary_message += "0"
            if abs(b - (b - alpha_prime)) > abs(b - (b + alpha_prime)):
                binary_message += "1"
            else:
                binary_message += "0"

            # 检查是否已经提取完整个消息
            if len(binary_message) >= 8 and binary_message[-8:] == "00000000":
                # 将二进制消息转换回字符串
                secret_message = ""
                for i in range(0, len(binary_message)-8, 8):
                    secret_message += chr(int(binary_message[i:i+8], 2))
                return secret_message

    # 如果未找到消息，则返回None
    return None

使用示例：

# 将秘密消息嵌入到图像中
encoded_image = encode_image("image.png", "Hello, world!", alpha=0.2)

# 保存嵌有秘密消息的图像
encoded_image.save("encoded_image.png")

# 从图像中提取秘密消息
secret_message = decode_image("encoded_image.png", alpha=0.2)
print(secret_message)