用DCGAN生成手寫體數字影象程式碼解析
util.py檔案把專案中用到的工具函式整理到一起,包括onehot,影象剪裁,影象拼接
# !/usr/bin/python
# -*- coding: utf-8 -*-
import cv2
import scipy.misc
import ipdb
import numpy as np
def OneHot(X, n=None, negative_class=0.):
#將輸入的矩陣壓平,轉化成向量l
X = np.asarray(X).flatten()
#得到輸入資料中最大的值
if n is None:
n = np.max(X) + 1
#生成l*n的矩陣,初始箇中元素都置為0
Xoh = np.ones((len(X), n)) * negative_class
#將矩陣每一行中X的值所對應的第n個位置置1,其他位為0
Xoh[np.arange(len(X)), X] = 1.
return Xoh
# 例:生成如下的矩陣
# [[ 0. 0. 0. ..., 0. 0. 0.]
# [ 0. 0. 0. ..., 0. 0. 1.]
# [ 1. 0. 0. ..., 0. 0. 0.]
# ...,
# [ 0. 0. 0. ..., 0. 0. 1.]
# [ 0. 0. 0. ..., 0. 0. 0.]
# [ 0. 0. 0. ..., 0. 0. 0.]]
def crop_resize(image_path, resize_shape=(64,64)):
#resize_image 必須是個正方形
image = cv2.imread(image_path)
height, width, channel = image.shape #得到輸入影象初始的引數
#if width != height, 新正方形的邊長是原來影象較短的那一條邊
#resize_image 位於原來影象的正中間區域
if width == height:
resized_image = cv2.resize(image, resize_shape)
elif width > height:
resized_image = cv2.resize(image, (int(width * float(resize_shape[0])/height), resize_shape[1]))
cropping_length = int( (resized_image.shape[1] - resize_shape[0]) / 2)
resized_image = resized_image[:,cropping_length:cropping_length+resize_shape[1]]
else:
resized_image = cv2.resize(image, (resize_shape[0], int(height * float(resize_shape[1])/width)))
cropping_length = int( (resized_image.shape[0] - resize_shape[1]) / 2)
resized_image = resized_image[cropping_length:cropping_length+resize_shape[0], :]
return resized_image/127.5 - 1#把返回的影象中每個畫素值的範圍壓縮在-1到1之間
#把原圖為28x28的影象拼湊起來組成一個392x392的影象
def save_visualization(X, (nh, nw), save_path='./vis/sample.jpg'):
h,w = X.shape[1], X.shape[2]
img = np.zeros((h * nh, w * nw, 3))
for n,x in enumerate(X):
j = n / nw
i = n % nw
img[j*h:j*h+h, i*w:i*w+w, :] = x
scipy.misc.imsave(save_path, img)
load.py檔案的作用是將MNIST資料匯入並進行資料集的劃分
# !/usr/bin/python
# -*- coding: utf-8 -*-
import sys
sys.path.append('..')
import numpy as np
import os
from time import time
from collections import Counter
import random
from matplotlib import pyplot as plt
data_dir = '/Users/Chris/MNIST_data'
def mnist():
#訓練集有六萬組資料
fd = open(os.path.join(data_dir,'train-images-idx3-ubyte'))
loaded = np.fromfile(file=fd,dtype=np.uint8)
trX = loaded[16:].reshape((60000,28*28)).astype(float)
fd = open(os.path.join(data_dir,'train-labels-idx1-ubyte'))
loaded = np.fromfile(file=fd,dtype=np.uint8)
trY = loaded[8:].reshape((60000))
#測試集有一萬組資料
fd = open(os.path.join(data_dir,'t10k-images-idx3-ubyte'))
loaded = np.fromfile(file=fd,dtype=np.uint8)
teX = loaded[16:].reshape((10000,28*28)).astype(float)
fd = open(os.path.join(data_dir,'t10k-labels-idx1-ubyte'))
loaded = np.fromfile(file=fd,dtype=np.uint8)
teY = loaded[8:].reshape((10000))
trY = np.asarray(trY)
teY = np.asarray(teY)
return trX, teX, trY, teY
def mnist_with_valid_set():
trX, teX, trY, teY = mnist()
#從訓練集取出後1萬組作為驗證集,前5萬組作為新的測試集
train_inds = range(len(trX))
np.random.shuffle(train_inds)
trX = trX[train_inds]
trY = trY[train_inds]
#trX, trY = shuffle(trX, trY)
vaX = trX[50000:]
vaY = trY[50000:]
trX = trX[:50000]
trY = trY[:50000]
return trX, vaX, teX, trY, vaY, teY
model.py是模型的網路結構,該檔案還包括模型會用到的啟用函式和正則化方法等
# !/usr/bin/python
#-*- coding: utf-8 -*-
import tensorflow as tf
import ipdb
def batchnormalize(X, eps=1e-8, g=None, b=None):
if X.get_shape().ndims == 4:
mean = tf.reduce_mean(X, [0,1,2])
std = tf.reduce_mean( tf.square(X-mean), [0,1,2] )
X = (X-mean) / tf.sqrt(std+eps)
if g is not None and b is not None:
g = tf.reshape(g, [1,1,1,-1])
b = tf.reshape(b, [1,1,1,-1])
X = X*g + b
elif X.get_shape().ndims == 2:
mean = tf.reduce_mean(X, 0)
std = tf.reduce_mean(tf.square(X-mean), 0)
X = (X-mean) / tf.sqrt(std+eps)
if g is not None and b is not None:
g = tf.reshape(g, [1,-1])
b = tf.reshape(b, [1,-1])
X = X*g + b
else:
raise NotImplementedError
return X
#此模型實用的啟用函式,形狀類似rule,但與rule不同的是x的負半軸那一部分的線段有斜率
def lrelu(X, leak=0.2):
f1 = 0.5 * (1 + leak)
f2 = 0.5 * (1 - leak)
return f1 * X + f2 * tf.abs(X)
def bce(o, t):
o = tf.clip_by_value(o, 1e-7, 1. - 1e-7)#將o中各個元素的值都壓縮在1e-7至1. - 1e-7之間
return -(t * tf.log(o) + (1.- t)*tf.log(1. - o))#交叉熵
class DCGAN():
def __init__(
self,
batch_size=100,
image_shape=[28,28,1],
dim_z=100,#噪聲z的維度
dim_y=10, #數字0 - 9, 10類
dim_W1=1024,
dim_W2=128,
dim_W3=64,
dim_channel=1,#灰度影象的通道數
):
self.batch_size = batch_size
self.image_shape = image_shape
self.dim_z = dim_z
self.dim_y = dim_y
self.dim_W1 = dim_W1
self.dim_W2 = dim_W2
self.dim_W3 = dim_W3
self.dim_channel = dim_channel
#初始化引數,在這裡設定name是為了訓練時獲取引數列表
self.gen_W1 = tf.Variable(tf.random_normal([dim_z+dim_y, dim_W1], stddev=0.02), name='gen_W1')
self.gen_W2 = tf.Variable(tf.random_normal([dim_W1+dim_y, dim_W2*7*7], stddev=0.02), name='gen_W2')
self.gen_W3 = tf.Variable(tf.random_normal([5,5,dim_W3,dim_W2+dim_y], stddev=0.02), name='gen_W3')
self.gen_W4 = tf.Variable(tf.random_normal([5,5,dim_channel,dim_W3+dim_y], stddev=0.02), name='gen_W4')
#64個大小為5x5的卷積核,通道數為11
self.discrim_W1 = tf.Variable(tf.random_normal([5,5,dim_channel+dim_y,dim_W3], stddev=0.02), name='discrim_W1')
#128個大小為5x5的卷積核,通道數為74
self.discrim_W2 = tf.Variable(tf.random_normal([5,5,dim_W3+dim_y,dim_W2], stddev=0.02), name='discrim_W2')
self.discrim_W3 = tf.Variable(tf.random_normal([dim_W2*7*7+dim_y,dim_W1], stddev=0.02), name='discrim_W3')
self.discrim_W4 = tf.Variable(tf.random_normal([dim_W1+dim_y,1], stddev=0.02), name='discrim_W4')
def build_model(self):
Z = tf.placeholder(tf.float32, [self.batch_size, self.dim_z])
Y = tf.placeholder(tf.float32, [self.batch_size, self.dim_y])
image_real = tf.placeholder(tf.float32, [self.batch_size]+self.image_shape)
image_gen = self.generate(Z,Y)
p_real = self.discriminate(image_real, Y)#真實影象判別概率
p_gen = self.discriminate(image_gen, Y)#生成影象判別概率
#判別網路的目標是讓真實影象的判別概率越接近1同時生成影象判別概率越接近0
discrim_cost_real = bce(p_real, tf.ones_like(p_real))
discrim_cost_gen = bce(p_gen, tf.zeros_like(p_gen))
discrim_cost = tf.reduce_mean(discrim_cost_real) + tf.reduce_mean(discrim_cost_gen)
#生成網路的目標是讓生成影象判別概率越接近1
gen_cost = tf.reduce_mean(bce( p_gen, tf.ones_like(p_gen) ))
return Z, Y, image_real, discrim_cost, gen_cost, p_real, p_gen
def discriminate(self, image, Y):
yb = tf.reshape(Y, tf.stack([self.batch_size, 1, 1, self.dim_y]))#shape=(128, 1, 1, 10)
X = tf.concat([image, yb*tf.ones([self.batch_size, 28, 28, self.dim_y])],3)#shape=(128, 28, 28, 11)
#第一層是個卷積層,得到64個14x14的feature map
h1 = lrelu( tf.nn.conv2d( X, self.discrim_W1, strides=[1,2,2,1], padding='SAME' ))#shape=(128, 14, 14, 64)
h1 = tf.concat([h1, yb*tf.ones([self.batch_size, 14, 14, self.dim_y])],3)#shape=(128, 14, 14, 74)
#第二層是個卷積層,得到128個7x7的feature map
h2 = lrelu( batchnormalize( tf.nn.conv2d( h1, self.discrim_W2, strides=[1,2,2,1], padding='SAME')) )#shape=(128, 7, 7, 128)
h2 = tf.reshape(h2, [self.batch_size, -1])#shape=(128, 6272)
h2 = tf.concat([h2, Y],1)#shape=(128, 6282)
#第三層是個全連線層,得到1024個輸出節點
h3 = lrelu( batchnormalize( tf.matmul(h2, self.discrim_W3 ) ))#shape=(128, 1024)
h3 = tf.concat([h3, Y],1)#shape=(128, 1034)
y = tf.nn.sigmoid(h3)#shape=(128, 1034)
return y
def generate(self, Z, Y):
#是discriminate()的逆過程
yb = tf.reshape(Y, [self.batch_size, 1, 1, self.dim_y])#shape=(128, 1, 1, 10)
Z = tf.concat([Z,Y],1)#shape=(128, 110)
#第一層是個全連線層
h1 = tf.nn.relu(batchnormalize(tf.matmul(Z, self.gen_W1)))#shape=(128, 1024)
h1 = tf.concat([h1, Y],1)#shape=(128, 1034)
#第二層是個全連線層
h2 = tf.nn.relu(batchnormalize(tf.matmul(h1, self.gen_W2)))#shape=(128, 6272)
h2 = tf.reshape(h2, [self.batch_size,7,7,self.dim_W2])#shape=(128, 7, 7, 128)
h2 = tf.concat([h2, yb*tf.ones([self.batch_size, 7, 7, self.dim_y])],3)#shape=(128, 7, 7, 138)
#第三層是個反捲積層
output_shape_l3 = [self.batch_size,14,14,self.dim_W3]
h3 = tf.nn.conv2d_transpose(h2, self.gen_W3, output_shape=output_shape_l3, strides=[1,2,2,1])#shape=(128, 14, 14, 64)
h3 = tf.nn.relu( batchnormalize(h3) )#shape=(128, 14, 14, 64)
h3 = tf.concat([h3, yb*tf.ones([self.batch_size, 14,14,self.dim_y])],3 )#shape=(128, 14, 14, 74)
#第四層是個反捲積層,得到28x28x1的影象
output_shape_l4 = [self.batch_size,28,28,self.dim_channel]
h4 = tf.nn.conv2d_transpose(h3, self.gen_W4, output_shape=output_shape_l4, strides=[1,2,2,1])#shape=(128, 28, 28, 1)
x = tf.nn.sigmoid(h4)#shape=(128, 28, 28, 1)
return x
def samples_generator(self, batch_size):
#結構與generate()相同,bacth_size設定的值與其不同,是為了將生成的一批影象拼接到一張例圖上
Z = tf.placeholder(tf.float32, [batch_size, self.dim_z])
Y = tf.placeholder(tf.float32, [batch_size, self.dim_y])
yb = tf.reshape(Y, [batch_size, 1, 1, self.dim_y])
Z_ = tf.concat([Z,Y],1)
h1 = tf.nn.relu(batchnormalize(tf.matmul(Z_, self.gen_W1)))
h1 = tf.concat([h1, Y],1)
h2 = tf.nn.relu(batchnormalize(tf.matmul(h1, self.gen_W2)))
h2 = tf.reshape(h2, [batch_size,7,7,self.dim_W2])
h2 = tf.concat( [h2, yb*tf.ones([batch_size, 7, 7, self.dim_y])],3)
output_shape_l3 = [batch_size,14,14,self.dim_W3]
h3 = tf.nn.conv2d_transpose(h2, self.gen_W3, output_shape=output_shape_l3, strides=[1,2,2,1])
h3 = tf.nn.relu( batchnormalize(h3) )
h3 = tf.concat([h3, yb*tf.ones([batch_size, 14,14,self.dim_y])],3 )
output_shape_l4 = [batch_size,28,28,self.dim_channel]
h4 = tf.nn.conv2d_transpose(h3, self.gen_W4, output_shape=output_shape_l4, strides=[1,2,2,1])
x = tf.nn.sigmoid(h4)
return Z,Y,x
train.py檔案用於訓練模型並生成樣例影象
# !/usr/bin/python
#-*- coding: utf-8 -*-
import ipdb
import os
import pandas as pd
import numpy as np
from model import *
from util import *
from load import mnist_with_valid_set
n_epochs = 100
learning_rate = 0.0002
batch_size = 128
image_shape = [28,28,1]
dim_z = 100
dim_W1 = 1024
dim_W2 = 128
dim_W3 = 64
dim_channel = 1
visualize_dim=196#196個生成的樣本影象拼湊在一起儲存為一張樣例圖,樣例圖的尺寸為392x392
trX, vaX, teX, trY, vaY, teY = mnist_with_valid_set()
# trX trY 訓練集
# vaX vaY 驗證集
# teX teY 測試集
dcgan_model = DCGAN(
batch_size=batch_size,
image_shape=image_shape,
dim_z=dim_z,
dim_W1=dim_W1,
dim_W2=dim_W2,
dim_W3=dim_W3,
)
Z_tf, Y_tf, image_tf, d_cost_tf, g_cost_tf, p_real, p_gen = dcgan_model.build_model()
# Z_tf 輸入隨機的資料
# Y_tf 輸出的類別(0-9個數字)
# image_tf batch_size個真實訓練影象
# d_cost_tf 判別網路的目標函式
# g_cost_tf 生成網路的目標函式
# p_real 真實影象的判別概率
# p_gen 生成影象的判別概率
sess = tf.InteractiveSession() #互動式使用對話
saver = tf.train.Saver(max_to_keep=10)
#得到判別網路和生成網路的引數列表
discrim_vars = filter(lambda x: x.name.startswith('discrim'), tf.trainable_variables())
gen_vars = filter(lambda x: x.name.startswith('gen'), tf.trainable_variables())
#訓練使用Adam進行優化,學習率設為0.0002
train_op_discrim = tf.train.AdamOptimizer(learning_rate, beta1=0.5).minimize(d_cost_tf, var_list=discrim_vars)
train_op_gen = tf.train.AdamOptimizer(learning_rate, beta1=0.5).minimize(g_cost_tf, var_list=gen_vars)
Z_tf_sample, Y_tf_sample, image_tf_sample = dcgan_model.samples_generator(batch_size=visualize_dim)
tf.initialize_all_variables().run()
Z_np_sample = np.random.uniform(-1, 1, size=(visualize_dim,dim_z))#從-1到1的均勻分佈中隨機取樣,得到196x100的矩陣
Y_np_sample = OneHot( np.random.randint(10, size=[visualize_dim]))#生成196x10的矩陣,對於每一行,隨機地在某一列置1
iterations = 0
k = 2
for epoch in range(n_epochs):
index = range(len(trY))#得到訓練資料的下標序列
np.random.shuffle(index)#置亂下標
#得到新的訓練資料序列
trX = trX[index]
trY = trY[index]
for start, end in zip(
range(0, len(trY), batch_size),#生成一個從0開始,至訓練資料數量大小結尾,間隔是128的序列,近似於[0,128,256,...]
range(batch_size, len(trY), batch_size)#與上一行得到的list相比,少了開始的一個0,[128,256,384,...]
):
#zip生成一個序列對[(0, 128), (128, 256), (256, 384),...],每一對相當於一個batch_size
Xs = trX[start:end].reshape( [-1, 28, 28, 1]) / 255.#畫素值限制在1以下
Ys = OneHot(trY[start:end])#生成128x10的矩陣,對於每一行,隨機地在某一列置1
Zs = np.random.uniform(-1, 1, size=[batch_size, dim_z]).astype(np.float32)#生成128組維數為100的隨機向量
#先訓練判別網路的引數,再訓練生成網路中的引數,交替進行
if np.mod( iterations, k ) != 0:
#喂進去Z、Y,得到生成影象;得到生成影象的判別概率;得到生成網路的目標函式,訓練優化其中的引數
_, gen_loss_val = sess.run(
[train_op_gen, g_cost_tf],
feed_dict={
Z_tf:Zs,
Y_tf:Ys
})
#喂進去Z、X、Y,得到生成影象,得到真實影象;得到生成影象判別概率和真實影象判別概率;得到判別網路的目標函式(未優化)
discrim_loss_val, p_real_val, p_gen_val = sess.run([d_cost_tf,p_real,p_gen], feed_dict={Z_tf:Zs, image_tf:Xs, Y_tf:Ys})
print "=========== updating G =========="
print "iteration:", iterations
print "gen loss:", gen_loss_val
print "discrim loss:", discrim_loss_val
else:
# 喂進去Z、X、Y,得到生成影象,得到真實影象;得到生成影象判別概率和真實影象判別概率;得到判別網路的目標函式,訓練優化其中的引數
_, discrim_loss_val = sess.run(
[train_op_discrim, d_cost_tf],
feed_dict={
Z_tf:Zs,
Y_tf:Ys,
image_tf:Xs
})
#喂進去Z、Y,得到生成影象;得到生成影象的判別概率;得到生成網路的目標函式(未優化)
gen_loss_val, p_real_val, p_gen_val = sess.run([g_cost_tf, p_real, p_gen], feed_dict={Z_tf:Zs, image_tf:Xs, Y_tf:Ys})
print "=========== updating D =========="
print "iteration:", iterations
print "gen loss:", gen_loss_val
print "discrim loss:", discrim_loss_val
print "Average P(real)=", p_real_val.mean()
print "Average P(gen)=", p_gen_val.mean()
#每200次epoch生成一張樣例圖。由於samples_generator中的引數和generate中的引數是一樣的,直接餵給其資料,就能享受到訓練了200*n輪後的成果
if np.mod(iterations, 200) == 0:
generated_samples = sess.run(
image_tf_sample,
feed_dict={
Z_tf_sample:Z_np_sample,
Y_tf_sample:Y_np_sample
})
generated_samples = (generated_samples + 1.)/2.#把畫素值的範圍由在-1到1轉化成0到1
save_visualization(generated_samples, (14,14), save_path='./vis/sample_'+str(iterations/200)+'.jpg')
iterations += 1
對於此專案,我還存在一些疑惑,比如說網路結構中Y(標籤)的數量10為什麼總被用於改變網路的結構:
h2 = tf.reshape(h2,[self.batch_size,7,7,self.dim_W2])#shape =(128,7,7,128)
h2 = tf.concat([h2,yb * tf.ones([self.batch_size,7,7,self.dim_y])],3)#shape =(128,7,7,138)
在這裡,h2增加了10個通道。它的作用是什麼呢?
相關推薦
用DCGAN生成手寫體數字影象程式碼解析
util.py檔案把專案中用到的工具函式整理到一起,包括onehot,影象剪裁,影象拼接 # !/usr/bin/python # -*- coding: utf-8 -*- import cv2 import scipy.misc import ip
基於MNIST資料集通過樸素貝葉斯學習生成隨機手寫體數字影象
好久沒寫部落格了,話不多說,進入主題。 1、貝葉斯方法 2、訓練資料集 3、具體實現過程 3.1 匯入資料集 上面提到的資料由於編碼問題,需要自己寫匯入方法,如果你也是用python的話,有現成的模板可以使用。推薦一個Gi
(二)用 svm 識別手寫體數字圖片
一、解決問題 手寫體數字識別 二、程式碼分析 1、載入資料 from sklearn.datasets import load_digits digits = load_digits() d
java用axis2生成webservice客戶端程式碼及使用方法
這兩天javaweb專案需要呼叫c#釋出的webService介面。自己琢磨了半天,到網上趙各種資料,有java自帶的wsimport方法,還有用axis2的jar包去生成。在實現中也遇到了一些問題,
12.【基礎】手寫體數字影象聚類--KMeans
本文所有實現程式碼均來自《Python機器學習及實戰》 #-*- coding:utf-8 -*- #分別匯入numpy、matplotlib、pandas,用於數學運算、作圖以及資料分析 import numpy as np import matplo
Android 用Java程式碼編寫一款動態生成幸運數字的小遊戲
截圖: 程式碼如下: 第三方依賴庫地址:https://github.com/AndroidMsky/RandomTextView 第一步:新增倉庫 allprojects { repositories { ... maven {
生成對抗網路GAN---生成mnist手寫數字影象示例(附程式碼)
Ian J. Goodfellow等人於2014年在論文Generative Adversarial Nets中提出了一個通過對抗過程估計生成模型的新框架。框架中同時訓練兩個模型:一個生成模型(generative model)G,用來捕獲資料分佈;一個判別模型(discri
用zxing生成和解析二維碼
ont 跳轉 char log trac -s ioe hints pan package test; import java.awt.image.BufferedImage; import java.io.File; import java.io.IOExceptio
程式設計師用軟體生成前端程式碼,前端妹子看完直接傻眼!卻遭領導批評
作為程式設計師經常會有一些口頭禪,比如說“程式碼複用思想”,“寫高質量的程式碼”,“程式碼在精不在多”,“思路比努力更重要”,這些話中大多強調的是策略的重要性,在工作中,勤奮固然重要,如果能在勤奮的基礎上強調一下方法與策略,那便會使工作起到事半功倍的效果,最近有一個程式設計師網友異於其他程式設計師,
[深度學習]半監督學習、無監督學習之DCGAN深度卷積生成對抗網路(附程式碼)
論文全稱:《Generative Adversarial Nets》 論文地址:https://arxiv.org/pdf/1406.2661.pdf 論文全稱:《UNSUPERVISED REPRESENTATION LEARNING WITH DEEP CONVOLUTIONAL GEN
數字影象處理——用Java對影象做映象變換
水平映象變換,也就是把影象的畫素點按照垂直中線做調換。 程式碼實現也很簡單: import javax.imageio.ImageIO; import java.awt.image.Buffer
NVIDIA新作解讀:用GAN生成前所未有的高清影象(附PyTorch復現) | PaperDaily #15
在碎片化閱讀充斥眼球的時代,越來越少的人會去關注每篇論文背後的探索和思考。 在這個欄目裡,你會快速 get 每篇精選論文的亮點和痛點,時刻緊跟 AI 前沿成果。 點選本文底部的「閱讀
數字影象處理MATLAB實現(第2版)岡薩雷斯 書中程式碼-2.1 intrans函式
持續更新。。。 function g = intrans(f, method,varargin) %INTRANS Performs intensity (gray-level) transformations. % G = INTRANS(F, 'n
【數字影象處理之(三)】用影象增強談灰度變換
調整索引色影象的調色盤map。如果low_in, high_in, low_out, high_out 和 gamma 都是標量,那麼對 r,g,b 分量同時都做此對映。對於每個顏色分量都有唯一的對映,當 low_in 和 high_in 同時為1*3向量或者 low_out 和 high_out 同時為1
數字影象處理Matlab程式碼【1基本原理】
今天開始學習岡薩雷斯的《數字影象處理》。本文主要記錄書中的例題,以便今後學習參考。-----------------------------------------------------------20180619------------------------------
wsdl介面,用cmd生成客戶端程式碼
wsimport -s D:\cos\pa -p com.sf.customer.service.core.web.ws.client.cos.paramTypeService -keep http://127.0.0.1:8080/cos_webservice/servi
《數字影象處理原理與實踐(MATLAB版)》一書之程式碼Part3
本文系《數字影象處理原理與實踐(MATLAB版)》一書之程式碼系列的Part3,輯錄該書第135至第184頁之程式碼,供有需要讀者下載研究使用。程式碼執行結果請參見原書配圖。-------------------------------------------P139orig
求旋轉陣列的最小數字演算法的解析以及完整c語言程式碼實現
首先了解什麼是旋轉陣列:即把一個數組的最開始的若干個元素搬到陣列的末尾,即成為旋轉陣列,例如陣列{3,7,1,8,2}為{1,8,2,3,7}的一個旋轉陣列。 題目:輸入一個遞增排序的陣列的一個旋轉,輸出旋轉陣列的最小元素,例如{1,2,
c# 圖形驗證碼生成 程式碼解析
之前做登入時,傳送簡訊驗證碼需要做安全控制,使用到了圖形驗證碼 使用的思路是: 1、建立一個驗證碼圖片生成器頁面 2、生成字母或數字組成的隨機字串 3、在Cookie中儲存隨機驗證碼 4、根據生成的隨機驗證碼,生成驗證碼圖片 5、前端呼叫該頁面,填寫
《數字影象處理原理與實踐(MATLAB版)》一書之程式碼Part1
本文系《數字影象處理原理與實踐(MATLAB版)》一書之程式碼系列的Part1(P1~42),程式碼執行結果請參見原書配圖。P20I = imread('lena.jpg');BW1 = im2bw(I