用Python写了一个数据格式转换小程序

44 篇文章 0 订阅
7 篇文章 0 订阅

1 为什么需要这个转换程序

数据量大到了一定程度,用手工转换费时费力,在这种情况下,必须依靠程序来快速地解决,以便于高效率的工作。显然,当数据量只有2个短行的时候,是不需要写个专门的程序处理的。

2 问题描述

转换前的数据格式是这样的,将该内容命名为TestDataBeforeTransfer.txt:

method: algorithm 1
20:
4 0.835
5 0.508
6 0.834
7 0.514
8 0.516
9 0.688
10 0.647
11 0.415
12 0.502
13 0.659
14 0.589
15 0.416
16 0.566
17 0.743
50:
4 0.835
5 0.508
6 0.834
7 0.514
8 0.516
9 0.688
10 0.647
11 0.415
12 0.502
13 0.659
14 0.653
15 0.484
16 0.619
17 0.743
times elaped: 10130

转换后的格式要求是这样的:

[0.835, 0.508, 0.834, 0.514, 0.516, 0.688, 0.647, 0.415, 0.502, 0.659, 0.589, 0.416, 0.566, 0.743]
[0.835, 0.508, 0.834, 0.514, 0.516, 0.688, 0.647, 0.415, 0.502, 0.659, 0.653, 0.484, 0.619, 0.743]

3 解决方法

3.1 程序代码

根据上面的问题描述,编写了以下的python程序,即可完成数据格式转换的任务,可将该程序命名为dformatTrans.py:

f = open('TestDataBeforeTransfer.txt','r')
lines = f.readlines()
f.close()

rbTag = False
vCount = 0
vValues = []
for line in lines:
    if line[-2] == ':':
        rbTag = True
    if rbTag == True and vCount < 14 and not line[-2] == ':' and not line[0] == 't':
        vCount +=1
        line = line[2:]
        line = line[:-1]
        vValues.append(float(line))
    else:
        vCount = 0
        if not len(vValues) ==0:
            print vValues
            vValues = []

程序的使用:将代码和数据文件放在同一个文件夹下,在该文件夹下运行cmd console程序,然后输入以下指令:

python dformatTrans.py > result.txt

在文件result.txt中即会出现转换后的结果。

3.2 为什么没有用re包

因为转换前的数据格式内容简单,没有什么复杂的字符,所以不需要使用正则表达式这样高级的东西。

4 总结

能用电脑帮忙处理的事情,千万不要使用手工来做。这是关系到效率的问题,高效率的工作就意味着能够在同一时间里收获更多。

  • 2
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
为了一个AI换脸的程序,你需要使用Python中的一些深度学习框架,如Tensorflow或PyTorch。 下面是一个基本的AI换脸程序的流程: 1. 收集数据集:收集需要进行换脸的两个人的头像数据集。 2. 训练模型:使用深度学习框架训练一个生成对抗网络(GAN)模型,该模型可以将一个人的脸转换为另一个人的脸。你可以使用Pix2Pix或CycleGAN等已有的GAN模型,或者自己设计一个GAN模型。 3. 测试模型:使用测试集对模型进行测试,确保它可以成功地将一个人的脸转换为另一个人的脸。 4. 应用模型:将模型应用于实际的图像中,将一个人的脸转换为另一个人的脸。 下面是一个简单的例子,使用Tensorflow和Pix2Pix模型实现AI换脸: 1. 收集数据集:收集需要进行换脸的两个人的头像数据集。 2. 训练模型: ``` python import tensorflow as tf import tensorflow_datasets as tfds from tensorflow_examples.models.pix2pix import pix2pix import os # 加载数据集 dataset, metadata = tfds.load('cycle_gan/monet2photo', with_info=True, as_supervised=True) # 划分训练集和测试集 train_monet, train_photo = dataset['trainA'], dataset['trainB'] test_monet, test_photo = dataset['testA'], dataset['testB'] # 将图像归一化到[-1,1] def normalize(input_image, input_mask): input_image = tf.cast(input_image, tf.float32) / 127.5 - 1 input_mask -= 1 return input_image, input_mask # 随机裁剪和调整大小 def random_jitter(input_image, input_mask): input_image, input_mask = normalize(input_image, input_mask) input_image = tf.image.resize(input_image, [286, 286], method=tf.image.ResizeMethod.NEAREST_NEIGHBOR) input_mask = tf.image.resize(input_mask, [286, 286], method=tf.image.ResizeMethod.NEAREST_NEIGHBOR) stacked_image = tf.stack([input_image, input_mask], axis=0) cropped_image = tf.image.random_crop(stacked_image, size=[2, 256, 256, 3]) input_image, input_mask = cropped_image[0], cropped_image[1] if tf.random.uniform(()) > 0.5: input_image = tf.image.flip_left_right(input_image) input_mask = tf.image.flip_left_right(input_mask) return input_image, input_mask # 批量读取数据 BUFFER_SIZE = 1000 BATCH_SIZE = 1 train_dataset = train_dataset.map(random_jitter).shuffle(BUFFER_SIZE).batch(BATCH_SIZE) test_dataset = test_dataset.map(normalize).batch(BATCH_SIZE) # 定义生成器和判别器 generator_g = pix2pix.unet_generator(3, norm_type='instancenorm') generator_f = pix2pix.unet_generator(3, norm_type='instancenorm') discriminator_x = pix2pix.discriminator(norm_type='instancenorm', target=False) discriminator_y = pix2pix.discriminator(norm_type='instancenorm', target=False) # 定义损失函数 loss_obj = tf.keras.losses.BinaryCrossentropy(from_logits=True) def discriminator_loss(real, generated): real_loss = loss_obj(tf.ones_like(real), real) generated_loss = loss_obj(tf.zeros_like(generated), generated) total_discriminator_loss = real_loss + generated_loss return total_discriminator_loss * 0.5 def generator_loss(generated): return loss_obj(tf.ones_like(generated), generated) # 定义优化器 generator_g_optimizer = tf.keras.optimizers.Adam(2e-4, beta_1=0.5) generator_f_optimizer = tf.keras.optimizers.Adam(2e-4, beta_1=0.5) discriminator_x_optimizer = tf.keras.optimizers.Adam(2e-4, beta_1=0.5) discriminator_y_optimizer = tf.keras.optimizers.Adam(2e-4, beta_1=0.5) # 定义检查点 checkpoint_path = "./checkpoints/train" ckpt = tf.train.Checkpoint(generator_g=generator_g, generator_f=generator_f, discriminator_x=discriminator_x, discriminator_y=discriminator_y, generator_g_optimizer=generator_g_optimizer, generator_f_optimizer=generator_f_optimizer, discriminator_x_optimizer=discriminator_x_optimizer, discriminator_y_optimizer=discriminator_y_optimizer) ckpt_manager = tf.train.CheckpointManager(ckpt, checkpoint_path, max_to_keep=5) # 训练模型 @tf.function def train_step(real_x, real_y): with tf.GradientTape(persistent=True) as tape: # 生成器G将X转换为Y' fake_y = generator_g(real_x, training=True) # 生成器F将Y'转换为X' fake_x = generator_f(fake_y, training=True) # 生成器F将X转换为Y'' cycled_y = generator_g(fake_x, training=True) # 生成器G将Y转换为X'' cycled_x = generator_f(fake_y, training=True) # 生成器G和生成器F的重建损失 id_x = generator_g(real_y, training=True) id_y = generator_f(real_x, training=True) # 判别器Dx的损失 disc_real_x = discriminator_x(real_x, training=True) disc_fake_x = discriminator_x(fake_x, training=True) # 判别器Dy的损失 disc_real_y = discriminator_y(real_y, training=True) disc_fake_y = discriminator_y(fake_y, training=True) # 总损失 gen_g_loss = generator_loss(disc_fake_y) + \ tf.reduce_mean(tf.abs(real_y - id_y)) * 10 + \ tf.reduce_mean(tf.abs(real_x - cycled_x)) * 10 gen_f_loss = generator_loss(disc_fake_x) + \ tf.reduce_mean(tf.abs(real_x - id_x)) * 10 + \ tf.reduce_mean(tf.abs(real_y - cycled_y)) * 10 total_gen_loss = gen_g_loss + gen_f_loss disc_x_loss = discriminator_loss(disc_real_x, disc_fake_x) disc_y_loss = discriminator_loss(disc_real_y, disc_fake_y) # 计算梯度 generator_g_gradients = tape.gradient(gen_g_loss, generator_g.trainable_variables) generator_f_gradients = tape.gradient(gen_f_loss, generator_f.trainable_variables) discriminator_x_gradients = tape.gradient(disc_x_loss, discriminator_x.trainable_variables) discriminator_y_gradients = tape.gradient(disc_y_loss, discriminator_y.trainable_variables) # 优化器更新权重 generator_g_optimizer.apply_gradients(zip(generator_g_gradients, generator_g.trainable_variables)) generator_f_optimizer.apply_gradients(zip(generator_f_gradients, generator_f.trainable_variables)) discriminator_x_optimizer.apply_gradients(zip(discriminator_x_gradients, discriminator_x.trainable_variables)) discriminator_y_optimizer.apply_gradients(zip(discriminator_y_gradients, discriminator_y.trainable_variables)) return gen_g_loss, gen_f_loss, disc_x_loss, disc_y_loss EPOCHS = 200 for epoch in range(EPOCHS): for real_x, real_y in train_dataset: gen_g_loss, gen_f_loss, disc_x_loss, disc_y_loss = train_step(real_x, real_y) if epoch % 10 == 0: ckpt_manager.save() ``` 3. 测试模型: ``` python import matplotlib.pyplot as plt # 从测试集中加载图像 sample_monet, sample_photo = next(iter(test_dataset)) # 生成换脸图像 generated_photo = generator_g(sample_monet, training=True) generated_monet = generator_f(sample_photo, training=True) # 显示图像 fig, axes = plt.subplots(2, 2, figsize=(12, 12)) axes[0, 0].imshow(sample_monet[0]) axes[0, 1].imshow(generated_photo[0]) axes[1, 0].imshow(sample_photo[0]) axes[1, 1].imshow(generated_monet[0]) plt.show() ``` 4. 应用模型: ``` python import cv2 # 读取两个人的头像 img1 = cv2.imread('img1.jpg') img2 = cv2.imread('img2.jpg') # 将头像调整为256x256大小 img1 = cv2.resize(img1, (256, 256)) img2 = cv2.resize(img2, (256, 256)) # 将头像归一化到[-1,1] img1 = (img1 / 127.5) - 1 img2 = (img2 / 127.5) - 1 # 将img1的脸转换为img2的脸 generated_img = generator_g(np.array([img1]), training=True)[0] # 将生成的图像调整回原始大小 generated_img = ((generated_img + 1) * 127.5).astype(np.uint8) generated_img = cv2.resize(generated_img, (img1.shape[1], img1.shape[0])) # 显示生成的图像 cv2.imshow('Generated Image', generated_img) cv2.waitKey() cv2.destroyAllWindows() ``` 这就是一个基本的AI换脸程序的实现过程。当然,这只是一个简单的例子,你可以根据自己的需要进行修改和扩展。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值