分类: Python

  • Python的MNIST预测

    import numpy as np  
    import tensorflow as tf  
    
    def get_data():  
        (x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()  
        x_test = x_test.reshape(-1, 28 * 28) / 255.0  # 展平并归一化  
        return x_test, y_test  
    
    def sigmoid(x):  
        return 1 / (1 + np.exp(-x))  
    
    def softmax(x在神经网络中,初始化权重时乘以一个小的常数(如 0.01)是一个常见的做法,):  
        exp_x = np.exp(x - np.max(x))  # 防止溢出  
        return exp_x / exp_x.sum(axis=1, keepdims=True)  
    
    def predict(network, x):  
        W1, W2, W3 = network['W1'], network['W2'], network['W3']  
        b1, b2, b3 = network['b1'], network['b2'], network['b3']  
        
        a1 = np.dot(x, W1) + b1  
        z1 = sigmoid(a1)  
        a2 = np.dot(z1, W2) + b2  
        z2 = sigmoid(a2)  
        a3 = np.dot(z2, W3) + b3  
        y = softmax(a3)  
        
        return y  
    
    # 初始化网络  
    def initialize_network(input_size, hidden_size1, hidden_size2, output_size):  
        network = {}  
        network['W1'] = np.random.randn(input_size, hidden_size1) * 0.01  
        network['b1'] = np.zeros((1, hidden_size1))  
        network['W2'] = np.random.randn(hidden_size1, hidden_size2) * 0.01  
        network['b2'] = np.zeros((1, hidden_size2))  
        network['W3'] = np.random.randn(hidden_size2, output_size) * 0.01  
        network['b3'] = np.zeros((1, output_size))  
        return network  
    
    # 主程序  
    x, ti = get_data()  # 获取测试数据和标签  
    network = initialize_network(28 * 28, 128, 64, 10)  # 初始化网络  
    
    accuracy_cnt = 0  
    for i in range(len(x)):  
        y = predict(network, x[i:i+1])  # 预测时需要保持输入的形状  
        p = np.argmax(y)  
        if p == ti[i]:  
            accuracy_cnt += 1  
    
    accuracy = accuracy_cnt / len(x)  
    print(f'Accuracy: {accuracy * 100:.2f}%')
    
    展开/折叠结果
    Accuracy: 9.58%
    

    在神经网络中,初始化权重时乘以一个小的常数(如 0.01)是一个常见的做法。如果权重初始化得太大,可能会导致在前向传播时激活值过大,从而在反向传播时产生非常大的梯度,导致梯度爆炸。相反,如果权重初始化得太小,可能会导致激活值接近于零,从而导致梯度消失。乘以一个小的常数可以帮助保持权重在一个合理的范围内,减少这些问题的发生。小的权重值可以使得神经元在初始阶段的输出更为平滑,避免在训练开始时产生过大的激活值。这有助于网络在训练初期更好地学习特征。

    np.zeros 是 NumPy 库中的一个函数,用于创建一个指定形状的数组,并将所有元素初始化为零。

  • python显示MNIST图像和标签

    import tensorflow as tf  
    import numpy as np
    import matplotlib.pyplot as plt
    
    mnist = tf.keras.datasets.mnist  
    (x_train, y_train), (x_test, y_test) = mnist.load_data()
    
    img = x_train[0]
    label = y_train[0]
    print(label)
    print(img.shape)
    
    
    def img_show(image):
    ...     plt.imshow(image)
    ...     plt.axis('off')  # Hide axes
    ...     plt.show()
    
    img_show(img)
    
    展开/折叠结果
    >>> print(label)
    5
    >>> print(img.shape)
    (28, 28)
    
  • python加载MNIST

    安装tensorflow

    pip install tensorflow
    

    加载MNIST

    import tensorflow as tf  
    
    mnist = tf.keras.datasets.mnist  
    (x_train, y_train), (x_test, y_test) = mnist.load_data()
    
    print(x_train.shape)
    print(y_train.shape)
    print(x_test.shape)
    print(y_test.shape)
    
    展开/折叠结果
    >>> print(x_train.shape)
    (60000, 28, 28)
    >>> print(y_train.shape)
    (60000,)
    >>> print(x_test.shape)
    (10000, 28, 28)
    >>> print(y_test.shape)
    (10000,)
    
  • python写一个ppm图片查看器

    首先,如果要绘制图像,需要导入graphics模块。

    打开文件是必须的。

    接下来,需要读取前三行,第一行是标准格式,第二行是宽度和高度,第三行是最大亮度值。

    我们用空列表来存储其余的部分,也就是RGB值,三个值为一组(元组),每一组代表一个像素也就是一个颜色。

    把RGB值转换成图像代码,然后输出。

    from graphics import graphics   # 导入graphics模块
         
    def main():   # 主函数
        image = open('tt.ppm', 'r')   # 打开图片文件
        image_format = image.readline().strip()   # 读取图片格式
        width_height = image.readline().strip().split(' ')   # 读取图片宽度和高度
        width = int(width_height[0])   # 提取宽度,保存为整数
        height = int(width_height[1])   # 提取高度,保存为整数
        max_rgb = int(image.readline())   # 读取最大RGB值
         
        full_image = []   # 建立空列表
        for line in image:   # 读取每一行
            line = line.strip().split()   # 去除空格和换行符,并分割为列表
            row = []   # 建立空列表     
            for i in range(0, len(line), 3):    # 循环读取RGB值,每3个值一组
                pixel = ( int(line[i]), int(line[i+1]), int(line[i+2]))   # 建立元组,保存RGB值
                row.append(pixel)   # 追加元组到列表
            full_image.append(row)   # 追加列表到列表
         
        scale = float(input('图像设置多大? '))   # 读取缩放比例,建议100
        gui = graphics(width * scale, height * scale, 'PPM图像查看器')   # 建立GUI窗口,设置大小和标题
        for row in range(len(full_image)):   # 循环绘制每一行
            for column in range(len(full_image[row])):   # 循环绘制每一列
                pixel = full_image[row][column]   # 读取当前像素
                color = gui.get_color_string(pixel[0], pixel[1], pixel[2])   # 转换为颜色字符串,如#003264
                gui.rectangle(column * scale, row * scale, scale, scale, color)   # 绘制矩形,设置位置和大小,颜色
        gui.draw()   # 显示图像
    
    main()   # 调用主函数
    

    结果为扩大了100倍的ppm图像。

  • python画一个国际象棋棋盘

    国际象棋是8×8的方形,我们假设每个方形一个像素。如果能够画对,我们再这个基础上放大到800×800像素就画成了一个棋盘。

    # 打开文件,没有则创建一个
    image = open('chessboard.ppm', 'w')
    # 写入ppm文件头
    image.write('P3\n8 8\n255\n')
    # 写入图像数据
    for i in range(8):
        for j in range(8):
            if (i+j)%2 == 0:
                image.write('255 255 255 ')
            else:
                image.write('0 0 0 ')
        image.write('\n')
    # 关闭文件
    image.close()
    

    这很好理解,用奇数和偶数来判断棋盘的颜色。偶数是白色,奇数是黑色。

    得到一个放大了的图片。从结果上来开,是对的,只不过软件显示的时候加了圆角,这不重要。

    下面,我们来放大棋盘。

    # 打开文件,没有则创建一个
    image = open('chessboard_scaled.ppm', 'w')
    # 写入ppm文件头
    image.write('P3\n800 800\n255\n')
    # 写入图像数据
    for i in range(8):
        for _ in range(100):  # 每个像素水平复制10次
            for j in range(8):
                if (i+j)%2 == 0:
                    for _ in range(100):  # 每个像素垂直复制10次
                        image.write('255 255 255 ')
                else:
                    for _ in range(100):  # 每个像素垂直复制10次
                        image.write('0 0 0 ')
            image.write('\n')
    # 关闭文件
    image.close()
    

    好了,让我们看看放大以后的图片吧,怎么样,还不错吧。

  • python画一个渐变图

    用字符来画图是一个很有意思的,实现这个目的,需要.ppm格式。在windows中,一般的图片查看器都看不了这个格式。推荐使用vscode的插件查看。

    1. 下载Visual Studio Code并安装。
    2. 打开后,按ctrl + shift + x,打开插件搜索,输入ppm view,安装,然后就可以在vscode中查看图片了。

    PPM格式介绍

    PPM格式一般包括3行设置值,后面跟RGB值。

    P3
    1 1
    255
    100 200 255
    

    第1行:P3表示一个标准,符合ASCII编码,基本上是固定不变的。

    第2行:1 1表示宽1,高1的图片。

    第3行:255表示像素最大亮度是255,通常也是固定的。

    第4行:RGB值,用空格分开,由于只有1行1列,因此只有一个RGB值。

    图像为:

    根据上面的情况,我们就可以利用python快速写一个渐变图了。

    # 打开一个名为test_image.ppm的文件,如果没有这个文件,则创建它。
    image = open('test_image.ppm', 'w')
    # 写入文件头信息,256x256的图像,最大值255
    image.write('P3\n256 256\n255\n') 
    # 循环256次,创建256行,每行256个像素
    for i in range(256):
        # 创建一个字符串,包含一个像素的RGB值,这里是i
        one_pixel = str(i) + ' ' + str(i) + ' ' + str(i) + ' '
        # 写入256次,每一次写入一行,包含256个像素的RGB值
        image.write(one_pixel * 256 + '\n')
    # 关闭文件
    image.close()
    
  • python读取文件并执行

    首先,我们需要新建一个txt文本,命名为file.txt,里面包含一条命令。

    print("Hello, world!")
    

    再新建一个.py文件,任何文件名都可以。读取文件,使用read()函数。

    # 打开文件
    file = open('file.txt', 'r')
    
    # 读取文件内容
    content = file.read()
    
    # 输出文件内容,用exec执行文本内容
    exec(content)
    
    # 关闭文件
    file.close()
    
    展开/折叠结果 Hello, world!
  • python字典和列表的混用

    我们建立一个数据查询系统,包含一些基本信息,只要输入正确的人名,就可以查到相应的信息。

    # 定义一个函数,根据输入的员工姓名,和基本信息。
    employees = [
      {'name':'张三', 'title':'教授', '邮箱':'aaa@aaa.aa'},
      {'name':'李四', 'title': '副教授', '邮箱':'bbb@bbb.bb', 'office':'222'},
      {'name':'王五', 'title': '讲师', '年龄': 29, 'office':'220'},
      {'name':'这六'}
    ]
    
    # 定义一个查询员工信息的函数
    def lookup_employee(employees):
        name = input('请输入人名: ')
        for employee in employees:
            if 'name' in employee and employee['name'] == name:
                print('Information for ' + name + ':')
                for key, value in employee.items():
                    print('  ' + str(key) + ' -> ' + str(value))
                return
        print('查无此人!')
    
    # 调用查询员工信息的函数
    lookup_employee(employees)
    
    展开/折叠结果 Employee name: 张三
    Information for 张三:
    name -> 张三
    title -> 教授
    邮箱 -> aaa@aaa.aa
  • python字典输出

    我们可以用for循环输出,可以借助变量输出,也可以使用函数输出,还能用函数来筛选符合条件的输出。试试看吧。

    # 构建一个字典,表示食物名称和卡路里的对应关系
    pantry = {'protein bar': 200, 'apple': 50, 'banana':110 }
    
    # 打印字典内容
    for key in pantry:
        print(key, pantry[key])
    
    # 通过变量打印字典内容
    for food, calories in pantry.items():
        print(food, calories)
    
    # 定义函数,显示字典内容
    def show_food(pantry):
        for key in pantry:
            print(key, '->', pantry[key])
    # 调用函数
    show_food(pantry)
    
    # 定义一个卡路里低于阈值的列表
    def low_calorie_food(pantry, threshold):
        for food, calories in pantry.items():
            if calories < threshold:
                print(food, '->', calories)
    
    # 调用函数
    low_calorie_food(pantry, 100)
    
    展开/折叠结果 protein bar 200
    apple 50
    banana 110

    protein bar 200
    apple 50
    banana 110

    protein bar -> 200
    apple -> 50
    banana -> 110

    apple -> 50
  • python的字典

    字典和传统意义上的字典完全不是一个概念。python中的字典或者编程中的字典表示的键值对的结合。每个键对应一个值。

    # 新建一个字典
    my_dict = {'name': 'John', 'age': 30, 'city': 'New York'}
    
    # 打印字典
    print(my_dict)
    
    # 向字典里添加内容
    my_dict['phone'] = '123-456-7890'
    
    # 打印字典
    print(my_dict)
    
    # 删除字典里的第一个元素
    del my_dict['name']
    
    # 打印字典
    print(my_dict)
    
    # 定义函数 show_dict 用于打印字典
    def show_dict(my_dict):
        for key, value in my_dict.items():
            print(key, ':', value)
    
    # 调用函数 show_dict 打印字典
    show_dict(my_dict)
    
    
    展开/折叠结果 {'name': 'John', 'age': 30, 'city': 'New York'}
    {'name': 'John', 'age': 30, 'city': 'New York', 'phone': '123-456-7890'}
    {'age': 30, 'city': 'New York', 'phone': '123-456-7890'}
    age : 30
    city : New York
    phone : 123-456-7890