AI人工智能深度学习算法：理论基础导论

    # 前向传播
    def forward_propagation(x, weights, biases):
    a = x
    for l in range(L-1):
        z = np.dot(a, weights[l]) + biases[l]
        a = activation_function(z)
    return a
    
    # 反向传播
    def backward_propagation(a, y, weights, biases):
    m = a.shape[1]
    dz = activation_derivative(a)
    delta = np.dot(dz, y - a)
    dW = (1/m) * np.dot(delta, a.T)
    db = (1/m) * np.sum(delta, axis=1, keepdims=True)
    a = a[:-1]
    for l in range(L-2, -1, -1):
        dz = activation_derivative(a)
        delta = np.dot(weights[l+1].T, delta)
        delta = dz * delta
        dW = (1/m) * np.dot(delta, a.T)
        db = (1/m) * np.sum(delta, axis=1, keepdims=True)
        a = a[:-1]
    return dW, db

    # 卷积操作
    def conv2d(x, W):
    return np.nn.functional.conv2d(x, W, padding='VALID')
    
    # 最大池化操作
    def max_pool2d(x, pool_size):
    return np.nn.functional.max_pool2d(x, pool_size, stride=pool_size)
    
    # CNN模型前向传播
    def forward_propagation(x, weights, biases):
    a = x
    for l in range(L-1):
        z = conv2d(a, weights[l]) + biases[l]
        a = activation_function(z)
        if l % 2 == 0:
            a = max_pool2d(a, pool_size)
    return a
    
    # CNN模型反向传播
    def backward_propagation(a, y, weights, biases):
    m = a.shape[1]
    dz = activation_derivative(a)
    delta = np.dot(dz, y - a)
    dW = (1/m) * np.dot(delta, a.T)
    db = (1/m) * np.sum(delta, axis=1, keepdims=True)
    a = a[:-1]
    for l in range(L-2, -1, -1):
        dz = activation_derivative(a)
        delta = np.dot(weights[l+1].T, delta)
        delta = dz * delta
        dW = (1/m) * np.dot(delta, a.T)
        db = (1/m) * np.sum(delta, axis=1, keepdims=True)
        a = a[:-1]
    return dW, db

    # RNN前向传播
    def forward_propagation(x, weights, biases):
    h = [x[0]]
    for t in range(1, T):
        z = np.dot(h[-1], weights['h']) + biases['h']
        h.append(np.tanh(np.dot(x[t], weights['xh']) + z))
    return h
    
    # LSTM前向传播
    def forward_propagation_lstm(x, weights, biases):
    h = [x[0]]
    for t in range(1, T):
        i = np.dot(h[-1], weights['ih']) + biases['ih']
        f = np.dot(h[-1], weights['fh']) + biases['fh']
        o = np.dot(h[-1], weights['oh']) + biases['oh']
        g = np.tanh(np.dot(h[-1], weights['ig']) + biases['ig'])
        h_prev = h[-1]
        h[t] = o * np.tanh(g + f * h_prev)
    return h
    
    # GRU前向传播
    def forward_propagation_gru(x, weights, biases):
    h = [x[0]]
    for t in range(1, T):
        z = np.dot(h[-1], weights['z']) + biases['z']
        r = np.dot(h[-1], weights['rh']) + biases['rh']
        h_prev = h[-1]
        h[t] = (1 - sigmoid(z)) * h_prev + sigmoid(z) * np.tanh(np.dot(h[-1], weights['rh']) + np.dot(h_prev, weights['hh']) + biases['hh'])
    return h
    
    # sigmoid函数
    def sigmoid(x):
    return 1 / (1 + np.exp(-x))

    import tensorflow as tf
    from tensorflow.keras.models import Sequential
    from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
    
    model = Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    MaxPooling2D((2, 2)),
    Conv2D(64, (3, 3), activation='relu'),
    MaxPooling2D((2, 2)),
    Flatten(),
    Dense(128, activation='relu'),
    Dense(10, activation='softmax')
    ])
    
    model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
    model.fit(x_train, y_train, epochs=10, batch_size=32, validation_data=(x_val, y_val))

    import tensorflow as tf
    from tensorflow.keras.models import Model
    from tensorflow.keras.layers import Input, Conv2D, LeakyReLU, ZeroPadding2D, BatchNormalization, MaxPooling2D, UpSampling2D, Concatenate
    
    input_shape = (416, 416, 3)
    
    def conv_block(x, filters, size, strides=(1, 1), padding='same', activation=True):
    x = Conv2D(filters, size, strides=strides, padding=padding)(x)
    if activation:
        x = LeakyReLU(alpha=0.1)(x)
    return x
    
    def residual_block(x, filters, size, strides=(1, 1), activation=True):
    x = ZeroPadding2D(padding=(1, 1))(x)
    x = conv_block(x, filters, size, strides=strides, activation=activation)
    x = BatchNormalization()(x)
    x = conv_block(x, filters, size, strides=(1, 1), activation=activation)
    return x
    
    inputs = Input(shape=input_shape)
    
    x = conv_block(inputs, 32, (3, 3))
    
    x = residual_block(x, 64, (3, 3), strides=(2, 2))
    x = residual_block(x, 128, (3, 3), strides=(2, 2))
    x = residual_block(x, 256, (3, 3), strides=(2, 2))
    x = residual_block(x, 512, (3, 3), strides=(2, 2))
    
    x = conv_block(x, 1024, (3, 3), activation=False)
    x = LeakyReLU(alpha=0.1)(x)
    x = GlobalAveragePooling2D()(x)
    
    x = Dense(1000, activation='relu')(x)
    outputs = Dense(2, activation='sigmoid')(x)
    
    model = Model(inputs=inputs, outputs=outputs)
    model.compile(optimizer='adam', loss='binary_crossentropy')
    
    model.fit(x_train, y_train, batch_size=32, epochs=10, validation_data=(x_val, y_val))

    import tensorflow as tf
    from tensorflow.keras.models import Model
    from tensorflow.keras.layers import Input, Dense, Reshape, Flatten
    from tensorflow.keras.layers import Conv2D, Conv2DTranspose, LeakyReLU, BatchNormalization, Activation, Embedding
    
    latent_dim = 100
    
    # 生成器
    generator = Sequential()
    generator.add(Dense(7 * 7 * 256, input_dim=latent_dim))
    generator.add(Reshape((7, 7, 256)))
    generator.add(BatchNormalization())
    generator.add(LeakyReLU(alpha=0.2))
    generator.add(Conv2DTranspose(128, kernel_size=5, strides=2, padding="same"))
    generator.add(BatchNormalization())
    generator.add(LeakyReLU(alpha=0.2))
    generator.add(Conv2DTranspose(64, kernel_size=5, strides=2, padding="same"))
    generator.add(BatchNormalization())
    generator.add(LeakyReLU(alpha=0.2))
    generator.add(Conv2DTranspose(1, kernel_size=5, strides=2, padding="same", activation='tanh'))
    
    # 判别器
    discriminator = Sequential()
    discriminator.add(Flatten(input_shape=(28, 28, 1)))
    discriminator.add(Dense(1024))
    discriminator.add(LeakyReLU(alpha=0.2))
    discriminator.add(Dense(1, activation='sigmoid'))
    
    # GAN模型
    z = Input(shape=(latent_dim,))
    img = generator(z)
    
    discriminator.trainable = False
    valid = discriminator(img)
    
    model = Model(z, valid)
    model.compile(loss='binary_crossentropy', optimizer=adam)
    
    for epoch in range(num_epochs):
    for _ in range(batch_size * num_batches_per_epoch):
        noise = np.random.normal(size=(batch_size, latent_dim))
        gen_imgs = generator.predict(noise)
    
        # 训练判别器
        d_loss_real = discriminator.train_on_batch(x_train, np.ones((batch_size, 1)))
        d_loss_fake = discriminator.train_on_batch(gen_imgs, np.zeros((batch_size, 1)))
    
        # 训练生成器
        g_loss = model.train_on_batch(noise, np.ones((batch_size, 1)))

    import tensorflow as tf
    from tensorflow.keras.models import Sequential
    from tensorflow.keras.layers import Embedding, LSTM, Dense
    
    # 参数设置
    vocab_size = 10000
    embed_size = 128
    lstm_units = 128
    batch_size = 64
    epochs = 10
    
    # 构建模型
    model = Sequential()
    model.add(Embedding(vocab_size, embed_size))
    model.add(LSTM(lstm_units, return_sequences=True))
    model.add(Dense(vocab_size, activation='softmax'))
    
    # 编译模型
    model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
    
    # 训练模型
    model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_data=(x_val, y_val))

    import tensorflow as tf
    from tensorflow.keras.models import Model
    from tensorflow.keras.layers import Input, LSTM, Dense, Embedding, TimeDistributed
    
    # 参数设置
    vocab_size = 10000
    embed_size = 128
    lstm_units = 128
    batch_size = 64
    epochs = 10
    
    # 构建编码器
    encoder_inputs = Input(shape=(None,))
    encoder_embedding = Embedding(vocab_size, embed_size)(encoder_inputs)
    encoder_lstm = LSTM(lstm_units, return_state=True)
    encoder_outputs, state_h, state_c = encoder_lstm(encoder_embedding)
    
    # 构建解码器
    decoder_inputs = Input(shape=(None,))
    decoder_embedding = Embedding(vocab_size, embed_size)(decoder_inputs)
    decoder_lstm = LSTM(lstm_units, return_sequences=True, return_state=True)
    decoder_outputs, _, _ = decoder_lstm(decoder_embedding, initial_state=[state_h, state_c])
    decoder_dense = TimeDistributed(Dense(vocab_size, activation='softmax'))
    decoder_outputs = decoder_dense(decoder_outputs)
    
    # 构建模型
    model = Model([encoder_inputs, decoder_inputs], decoder_outputs)
    
    # 编译模型
    model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
    
    # 训练模型
    model.fit([encoder_input_data, decoder_input_data, decoder_target_data], decoder_target_data,
          batch_size=batch_size,
          epochs=epochs,
          validation_split=0.2)

    import tensorflow as tf
    from tensorflow.keras.models import Model
    from tensorflow.keras.layers import Input, LSTM, Dense, Embedding
    
    # 参数设置
    vocab_size = 10000
    embed_size = 128
    lstm_units = 128
    batch_size = 64
    epochs = 10
    
    # 构建编码器
    encoder_inputs = Input(shape=(None,))
    encoder_embedding = Embedding(vocab_size, embed_size)(encoder_inputs)
    encoder_lstm = LSTM(lstm_units, return_state=True)
    encoder_outputs, state_h, state_c = encoder_lstm(encoder_embedding)
    
    # 构建解码器
    decoder_inputs = Input(shape=(None,))
    decoder_embedding = Embedding(vocab_size, embed_size)(decoder_inputs)
    decoder_lstm = LSTM(lstm_units, return_sequences=True, return_state=True)
    decoder_outputs, _, _ = decoder_lstm(decoder_embedding, initial_state=[state_h, state_c])
    decoder_dense = TimeDistributed(Dense(vocab_size, activation='softmax'))
    decoder_outputs = decoder_dense(decoder_outputs)
    
    # 构建模型
    model = Model([encoder_inputs, decoder_inputs], decoder_outputs)
    
    # 编译模型
    model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
    
    # 训练模型
    model.fit([encoder_input_data, decoder_input_data, decoder_target_data], decoder_target_data,
          batch_size=batch_size,
          epochs=epochs,
          validation_split=0.2)

    import tensorflow as tf
    from tensorflow.keras.models import Sequential
    from tensorflow.keras.layers import Dense
    from tensorflow.keras.optimizers import SGD
    
    # 参数设置
    learning_rate = 0.01
    num_epochs = 100
    
    # 构建模型
    model = Sequential([
    Dense(64, input_shape=(784,), activation='relu'),
    Dense(10, activation='softmax')
    ])
    
    # 编译模型
    model.compile(optimizer=SGD(learning_rate), loss='categorical_crossentropy', metrics=['accuracy'])
    
    # 训练模型
    model.fit(x_train, y_train, batch_size=64, epochs=num_epochs, validation_data=(x_val, y_val))

    from sklearn.model_selection import GridSearchCV
    from sklearn.svm import SVC
    from sklearn.datasets import load_iris
    
    # 加载数据
    iris = load_iris()
    X = iris.data
    y = iris.target
    
    # 定义模型和参数范围
    model = SVC()
    param_grid = {'C': [0.1, 1, 10], 'gamma': [0.1, 1, 10]}
    
    # 执行网格搜索
    grid_search = GridSearchCV(model, param_grid, cv=5)
    grid_search.fit(X, y)
    
    # 输出最优参数
    print("Best parameters:", grid_search.best_params_)
    print("Best score:", grid_search.best_score_)

    # 前向传播
    def forward_propagation(x, weights, biases):
    a = x
    for l in range(L-1):
        z = np.dot(a, weights[l]) + biases[l]
        a = activation_function(z)
    return a
    
    # 反向传播
    def backward_propagation(a, y, weights, biases):
    m = a.shape[1]
    dz = activation_derivative(a)
    delta = np.dot(dz, y - a)
    dW = (1/m) * np.dot(delta, a.T)
    db = (1/m) * np.sum(delta, axis=1, keepdims=True)
    a = a[:-1]
    for l in range(L-2, -1, -1):
        dz = activation_derivative(a)
        delta = np.dot(weights[l+1].T, delta)
        delta = dz * delta
        dW = (1/m) * np.dot(delta, a.T)
        db = (1/m) * np.sum(delta, axis=1, keepdims=True)
        a = a[:-1]
    return dW, db

    # 卷积操作
    def conv2d(x, W):
    return np.nn.functional.conv2d(x, W, padding='VALID')
    
    # 最大池化操作
    def max_pool2d(x, pool_size):
    return np.nn.functional.max_pool2d(x, pool_size, stride=pool_size)
    
    # CNN模型前向传播
    def forward_propagation(x, weights, biases):
    a = x
    for l in range(L-1):
        z = conv2d(a, weights[l]) + biases[l]
        a = activation_function(z)
        if l % 2 == 0:
            a = max_pool2d(a, pool_size)
    return a
    
    # CNN模型反向传播
    def backward_propagation(a, y, weights, biases):
    m = a.shape[1]
    dz = activation_derivative(a)
    delta = np.dot(dz, y - a)
    dW = (1/m) * np.dot(delta, a.T)
    db = (1/m) * np.sum(delta, axis=1, keepdims=True)
    a = a[:-1]
    for l in range(L-2, -1, -1):
        dz = activation_derivative(a)
        delta = np.dot(weights[l+1].T, delta)
        delta = dz * delta
        dW = (1/m) * np.dot(delta, a.T)
        db = (1/m) * np.sum(delta, axis=1, keepdims=True)
        a = a[:-1]
    return dW, db

    # RNN前向传播
    def forward_propagation(x, weights, biases):
    h = [x[0]]
    for t in range(1, T):
        z = np.dot(h[-1], weights['h']) + biases['h']
        h.append(np.tanh(np.dot(x[t], weights['xh']) + z))
    return h
    
    # LSTM前向传播
    def forward_propagation_lstm(x, weights, biases):
    h = [x[0]]
    for t in range(1, T):
        i = np.dot(h[-1], weights['ih']) + biases['ih']
        f = np.dot(h[-1], weights['fh']) + biases['fh']
        o = np.dot(h[-1], weights['oh']) + biases['oh']
        g = np.tanh(np.dot(h[-1], weights['ig']) + biases['ig'])
        h_prev = h[-1]
        h[t] = o * np.tanh(g + f * h_prev)
    return h
    
    # GRU前向传播
    def forward_propagation_gru(x, weights, biases):
    h = [x[0]]
    for t in range(1, T):
        z = np.dot(h[-1], weights['z']) + biases['z']
        r = np.dot(h[-1], weights['rh']) + biases['rh']
        h_prev = h[-1]
        h[t] = (1 - sigmoid(z)) * h_prev + sigmoid(z) * np.tanh(np.dot(h[-1], weights['rh']) + np.dot(h_prev, weights['hh']) + biases['hh'])
    return h
    
    # sigmoid函数
    def sigmoid(x):
    return 1 / (1 + np.exp(-x))

    import tensorflow as tf
    from tensorflow.keras.models import Sequential
    from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
    
    model = Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    MaxPooling2D((2, 2)),
    Conv2D(64, (3, 3), activation='relu'),
    MaxPooling2D((2, 2)),
    Flatten(),
    Dense(128, activation='relu'),
    Dense(10, activation='softmax')
    ])
    
    model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
    model.fit(x_train, y_train, epochs=10, batch_size=32, validation_data=(x_val, y_val))

    import tensorflow as tf
    from tensorflow.keras.models import Model
    from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense
    
    input_shape = (416, 416, 3)
    
    model = Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=input_shape),
    MaxPooling2D((2, 2)),
    Conv2D(64, (3, 3), activation='relu'),
    MaxPooling2D((2, 2)),
    Conv2D(128, (3, 3), activation='relu'),
    MaxPooling2D((2, 2)),
    Flatten(),
    Dense(512, activation='relu'),
    Dense(2, activation='sigmoid')
    ])
    
    model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])
    model.fit(x_train, y_train, epochs=10, batch_size=32, validation_data=(x_val, y_val))

    import tensorflow as tf
    from tensorflow.keras.models import Sequential
    from tensorflow.keras.layers import Embedding, LSTM, Dense
    
    model = Sequential()
    model.add(Embedding(vocab_size, embed_size))
    model.add(LSTM(lstm_units, return_sequences=True))
    model.add(Dense(vocab_size, activation='softmax'))
    
    model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
    model.fit(x_train, y_train, batch_size=batch_size, epochs=epochs, validation_data=(x_val, y_val))

    import tensorflow as tf
    from tensorflow.keras.models import Model
    from tensorflow.keras.layers import Input, LSTM, Dense, Embedding, TimeDistributed
    
    input_shape = (None,)
    
    # 构建编码器
    encoder_inputs = Input(shape=input_shape)
    encoder_embedding = Embedding(vocab_size, embed_size)(encoder_inputs)
    encoder_lstm = LSTM(lstm_units, return_state=True)
    encoder_outputs, state_h, state_c = encoder_lstm(encoder_embedding)
    
    # 构建解码器
    decoder_inputs = Input(shape=input_shape)
    decoder_embedding = Embedding(vocab_size, embed_size)(decoder_inputs)
    decoder_lstm = LSTM(lstm_units, return_sequences=True, return_state=True)
    decoder_outputs, _, _ = decoder_lstm(decoder_embedding, initial_state=[state_h, state_c])
    decoder_dense = TimeDistributed(Dense(vocab_size, activation='softmax'))
    decoder_outputs = decoder_dense(decoder_outputs)
    
    # 构建模型
    model = Model([encoder_inputs, decoder_inputs], decoder_outputs)
    
    model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
    
    model.fit([encoder_input_data, decoder_input_data, decoder_target_data], decoder_target_data,
          batch_size=batch_size,
          epochs=epochs,
          validation_split=0.2)

    import tensorflow as tf
    from tensorflow.keras.models import Model
    from tensorflow.keras.layers import Input, LSTM, Dense, Embedding, TimeDistributed
    
    input_shape = (None,)
    
    # 构建编码器
    encoder_inputs = Input(shape=input_shape)
    encoder_embedding = Embedding(vocab_size, embed_size)(encoder_inputs)
    encoder_lstm = LSTM(lstm_units, return_state=True)
    encoder_outputs, state_h, state_c = encoder_lstm(encoder_embedding)
    
    # 构建解码器
    decoder_inputs = Input(shape=input_shape)
    decoder_embedding = Embedding(vocab_size, embed_size)(decoder_inputs)
    decoder_lstm = LSTM(lstm_units, return_sequences=True, return_state=True)
    decoder_outputs, _, _ = decoder_lstm(decoder_embedding, initial_state=[state_h, state_c])
    decoder_dense = TimeDistributed(Dense(vocab_size, activation='softmax'))
    decoder_outputs = decoder_dense(decoder_outputs)
    
    # 构建模型
    model = Model([encoder_inputs, decoder_inputs], decoder_outputs)
    
    model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])
    
    model.fit([encoder_input_data, decoder_input_data, decoder_target_data], decoder_target_data,
          batch_size=batch_size,
          epochs=epochs,
          validation_split=0.2)