原文：LearningTensorFlow.com

譯者：飛龍

協議：CC BY-NC-SA 4.0

自豪地採用谷歌翻譯

聚類和 KMeans

我們現在冒險進入我們的第一個應用，即使用 k-means 演算法進行聚類。 聚類是一種資料探勘練習，我們獲取大量資料並找到彼此相似的點的分組。 K-means 是一種非常善於在許多型別的資料集中查詢簇的演算法。

對於簇和 k-means的 更多資訊，請參閱 k-means 演算法的 scikit-learn 文件或觀看此視訊。

生成樣本

首先，我們需要生成一些樣本。 我們可以隨機生成樣本，但這可能會給我們提供非常稀疏的點，或者只是一個大分組 - 對於聚類來說並不是非常令人興奮。

相反，我們將從生成三個質心開始，然後在該點周圍隨機選擇（具有正態分佈）。 首先，這是一個執行此操作的方法

import tensorflow as tf
import numpy as np


def create_samples(n_clusters, n_samples_per_cluster, n_features, embiggen_factor, seed):
    np.random.seed(seed)
    slices = []
    centroids = []
    # 為每個簇建立樣本
    for i in range(n_clusters):
        samples =
 
 tf.random_normal((n_samples_per_cluster, n_features),
                                   mean=0.0, stddev=5.0, dtype=tf.float32, seed=seed, name="cluster_{}".format(i))
        current_centroid = (np.random.random((1, n_features)) * embiggen_factor) - (embiggen_factor/2)
        centroids.append(current_centroid)
 

        samples += current_centroid
        slices.append(samples)
    # 建立一個大的“樣本”資料集
    samples = tf.concat(slices, 0, name='samples')
    centroids = tf.concat(centroids, 0, name='centroids')
    return centroids, samples

這種方法的工作方式是隨機建立n_clusters個不同的質心（使用np.random.random((1, n_features))）並將它們用作tf.random_normal的質心。 tf.random_normal函式生成正態分佈的隨機值，然後我們將其新增到當前質心。 這會在該形心周圍建立一些點。 然後我們記錄質心（centroids.append）和生成的樣本（slices.append(samples)）。 最後，我們使用tf.concat建立“一個大樣本列表”，並使用tf.concat將質心轉換為 TensorFlow 變數。

將create_samples方法儲存在名為functions.py的檔案中，允許我們為這個（以及下一個！）課程，將這些方法匯入到我們的指令碼中。 建立一個名為generate_samples.py的新檔案，其中包含以下程式碼：

import tensorflow as tf
import numpy as np

from functions import create_samples

n_features = 2
n_clusters = 3
n_samples_per_cluster = 500
seed = 700
embiggen_factor = 70

np.random.seed(seed)

centroids, samples = create_samples(n_clusters, n_samples_per_cluster, n_features, embiggen_factor, seed)

model = tf.global_variables_initializer()
with tf.Session() as session:
    sample_values = session.run(samples)
    centroid_values = session.run(centroids)

這只是設定了簇和特徵的數量（我建議將特徵的數量保持為 2，以便我們以後可以視覺化它們），以及要生成的樣本數。 增加embiggen_factor將增加簇的“散度”或大小。 我在這裡選擇了一個提供良好學習機會的值，因為它可以生成視覺上可識別的叢集。

為了使結果視覺化，我們使用matplotlib建立繪圖函式。 將此程式碼新增到functions.py：

def plot_clusters(all_samples, centroids, n_samples_per_cluster):
    import matplotlib.pyplot as plt
    # 繪製出不同的簇
    # 為每個簇選擇不同的顏色
    colour = plt.cm.rainbow(np.linspace(0,1,len(centroids)))
    for i, centroid in enumerate(centroids):
        # 為給定簇抓取樣本，並用新顏色繪製出來
        samples = all_samples[i*n_samples_per_cluster:(i+1)*n_samples_per_cluster]
        plt.scatter(samples[:,0], samples[:,1], c=colour[i])
        # 還繪製質心
        plt.plot(centroid[0], centroid[1], markersize=35, marker="x", color='k', mew=10)
        plt.plot(centroid[0], centroid[1], markersize=30, marker="x", color='m', mew=5)
     plt.show()

所有這些程式碼都是使用不同的顏色繪製每個簇的樣本，並在質心位置建立一個大的紅色X。 質心提供為引數，稍後會很方便。

更新generate_samples.py，通過將import plot_clusters新增到檔案頂部來匯入此函式。 然後，將這行程式碼新增到底部：

plot_clusters(sample_values, centroid_values, n_samples_per_cluster)

執行generate_samples.py現在應該提供以下繪圖：

初始化

k-means 演算法從初始質心的選擇開始，初始質心只是資料中實際質心的隨機猜測。 以下函式將從資料集中隨機選擇多個樣本作為此初始猜測：

def choose_random_centroids(samples, n_clusters):
    # 第 0 步：初始化：選擇 n_clusters 個隨機點
    n_samples = tf.shape(samples)[0]
    random_indices = tf.random_shuffle(tf.range(0, n_samples))
    begin = [0,]
    size = [n_clusters,]
    size[0] = n_clusters
    centroid_indices = tf.slice(random_indices, begin, size)
    initial_centroids = tf.gather(samples, centroid_indices)
    return initial_centroids

這段程式碼首先為每個樣本建立一個索引（使用tf.range(0, n_samples)，然後隨機打亂它。從那裡，我們使用tf.slice選擇固定數量（n_clusters）的索引。這些索引與我們的初始質心相關，然後使用tf.gather組合在一起形成我們的初始質心陣列。

將這個新的choose_random_centorids函式新增到functions.py中，並建立一個新指令碼（或更新前一個指令碼），寫入以下內容：

import tensorflow as tf
import numpy as np

from functions import create_samples, choose_random_centroids, plot_clusters

n_features = 2
n_clusters = 3
n_samples_per_cluster = 500
seed = 700
embiggen_factor = 70

centroids, samples = create_samples(n_clusters, n_samples_per_cluster, n_features, embiggen_factor, seed)
initial_centroids = choose_random_centroids(samples, n_clusters)

model = tf.global_variables_initializer()
with tf.Session() as session:
    sample_values = session.run(samples)
    updated_centroid_value = session.run(initial_centroids)

plot_clusters(sample_values, updated_centroid_value, n_samples_per_cluster)

這裡的主要變化是我們為這些初始質心建立變數，並在會話中計算其值。 然後，我們將初始猜測繪製到plot_cluster，而不是用於生成資料的實際質心。

執行此操作會將得到與上面類似的影象，但質心將處於隨機位置。 嘗試執行此指令碼幾次，注意質心移動了很多。

更新質心

在開始對質心位置進行一些猜測之後，然後 k-means 演算法基於資料更新那些猜測。 該過程是為每個樣本分配一個簇號，表示它最接近的質心。 之後，將質心更新為分配給該簇的所有樣本的平均值。 以下程式碼處理分配到最近的簇的步驟：

def assign_to_nearest(samples, centroids):
    # 為每個樣本查詢最近的質心

    # START from http://esciencegroup.com/2016/01/05/an-encounter-with-googles-tensorflow/
    expanded_vectors = tf.expand_dims(samples, 0)
    expanded_centroids = tf.expand_dims(centroids, 1)
    distances = tf.reduce_sum( tf.square(
               tf.subtract(expanded_vectors, expanded_centroids)), 2)
    mins = tf.argmin(distances, 0)
    # END from http://esciencegroup.com/2016/01/05/an-encounter-with-googles-tensorflow/
    nearest_indices = mins
    return nearest_indices

請注意，我從這個頁面借用了一些程式碼，這些程式碼具有不同型別的 k-means 演算法，以及許多其他有用的資訊。

這種方法的工作方式是計算每個樣本和每個質心之間的距離，這通過distances =那行來實現。 這裡的距離計算是歐幾里德距離。 這裡重要的一點是tf.subtract會自動擴充套件兩個引數的大小。 這意味著將我們作為矩陣的樣本，和作為列向量的質心將在它們之間產生成對減法。 為了實現，我們使用tf.expand_dims為樣本和質心建立一個額外的維度，強制tf.subtract的這種行為。

下一步程式碼處理質心更新：

def update_centroids(samples, nearest_indices, n_clusters):
    # 將質心更新為與其相關的所有樣本的平均值。
    nearest_indices = tf.to_int32(nearest_indices)
    partitions = tf.dynamic_partition(samples, nearest_indices, n_clusters)
    new_centroids = tf.concat([tf.expand_dims(tf.reduce_mean(partition, 0), 0) for partition in partitions], 0)
    return new_centroids

此程式碼選取每個樣本的最近索引，並使用tf.dynamic_partition將這些索引分到單獨的組中。 從這裡開始，我們在一個組中使用tf.reduce_mean來查詢該組的平均值，從而形成新的質心。 我們只需將它們連線起來形成我們的新質心。

現在我們有了這個部分，我們可以將這些呼叫新增到我們的指令碼中（或者建立一個新指令碼）：

import tensorflow as tf
import numpy as np

from functions import *

n_features = 2
n_clusters = 3
n_samples_per_cluster = 500
seed = 700
embiggen_factor = 70


data_centroids, samples = create_samples(n_clusters, n_samples_per_cluster, n_features, embiggen_factor, seed)
initial_centroids = choose_random_centroids(samples, n_clusters)
nearest_indices = assign_to_nearest(samples, initial_centroids)
updated_centroids = update_centroids(samples, nearest_indices, n_clusters)

model = tf.global_variables_initializer()
with tf.Session() as session:
    sample_values = session.run(samples)
    updated_centroid_value = session.run(updated_centroids)
    print(updated_centroid_value)

plot_clusters(sample_values, updated_centroid_value, n_samples_per_cluster)

此程式碼將：

• 從初始質心生成樣本
• 隨機選擇初始質心
• 關聯每個樣本和最近的質心
• 將每個質心更新為與關聯的樣本的平均值

這是 k-means 的單次迭代！ 我鼓勵你們練習一下，把它變成一個迭代版本。

1）傳遞給generate_samples的種子選項可確保每次執行指令碼時，“隨機”生成的樣本都是一致的。 我們沒有將種子傳遞給choose_random_centroids函式，這意味著每次執行指令碼時這些初始質心都不同。 更新指令碼來為隨機質心包含新的種子。

2）迭代地執行 k 均值演算法，其中來自之前迭代的更新的質心用於分配簇，然後用於更新質心，等等。 換句話說，演算法交替呼叫assign_to_nearest和update_centroids。 在停止之前，更新程式碼來執行此迭代 10 次。 你會發現，隨著 k-means 的更多迭代，得到的質心平均上更接近。 （對於那些對 k-means 有經驗的人，未來的教程將研究收斂函式和其他停止標準。）

訓練和收斂

大多數人工智慧和機器學習的關鍵組成部分是迴圈，即系統在多次訓練迭代中得到改善。 以這種方式訓練的一種非常簡單的方法，就是在for迴圈中執行更新。 我們在第 2 課中看到了這種方式的一個例子：

import tensorflow as tf


x = tf.Variable(0, name='x')

model = tf.global_variables_initializer()

with tf.Session() as session:
    for i in range(5):
        session.run(model)
        x = x + 1
        print(session.run(x))

我們可以改變此工作流，使用變數來收斂迴圈，如下所示：

import tensorflow as tf

x = tf.Variable(0., name='x')
threshold = tf.constant(5.)

model = tf.global_variables_initializer()

with tf.Session() as session:
    session.run(model)
    while session.run(tf.less(x, threshold)):
        x = x + 1
        x_value = session.run(x)
        print(x_value)

這裡的主要變化是，迴圈現在是一個while迴圈，測試（tf.less用於小於測試）為真時繼續迴圈。 在這裡，我們測試x是否小於給定閾值（儲存在常量中），如果是，我們繼續迴圈。

梯度下降

任何機器學習庫都必須具有梯度下降演算法。 我認為這是一個定律。 無論如何，Tensorflow 在主題上有一些變化，它們可以直接使用。

梯度下降是一種學習演算法，嘗試最小化某些誤差。 你問哪個誤差？ 嗯，這取決於我們，雖然有一些常用的方法。

讓我們從一個基本的例子開始：

import tensorflow as tf
import numpy as np

# x 和 y 是我們的訓練資料的佔位符
x = tf.placeholder("float")
y = tf.placeholder("float")
# w 是儲存我們的值的變數。 它使用“猜測”來初始化
# w[0] 是我們方程中的“a”，w[1] 是“b”
w = tf.Variable([1.0, 2.0], name="w")
# 我們的模型是 y = a*x + b
y_model = tf.multiply(x, w[0]) + w[1]

# 我們的誤差定義為差異的平方
error = tf.square(y - y_model)
# GradientDescentOptimizer 完成繁重的工作
train_op = tf.train.GradientDescentOptimizer(0.01).minimize(error)

# TensorFlow 常規 - 初始化值，建立會話並執行模型
model = tf.global_variables_initializer()

with tf.Session() as session:
    session.run(model)
    for i in range(1000):
        x_value = np.random.rand()
        y_value = x_value * 2 + 6
        session.run(train_op, feed_dict={x: x_value, y: y_value})

    w_value = session.run(w)
    print("Predicted model: {a:.3f}x + {b:.3f}".format(a=w_value[0], b=w_value[1]))

這裡的主要興趣點是train_op = tf.train.GradientDescentOptimizer(0.01).minimize(error)，其中定義了訓練步長。 它旨在最小化誤差變數的值，該變數先前被定義為差的平方（常見的誤差函式）。 0.01 是嘗試學習更好的值所需的步長。

其它優化器

TensorFlow 有一整套優化器，並且你也可以定義自己的優化器（如果你對這類事情感興趣）。 如何使用它們的 API，請參閱此頁面。 列表如下：

• GradientDescentOptimizer
• AdagradOptimizer
• MomentumOptimizer
• AdamOptimizer
• FtrlOptimizer
• RMSPropOptimizer

其他優化方法可能會出現在 TensorFlow 的未來版本或第三方程式碼中。 也就是說，上述優化對於大多數深度學習技術來說已經足夠了。 如果你不確定要使用哪一個，請使用AdamOptimizer，除非失敗。

譯者注：原文推薦隨機梯度優化器，在所有優化器裡是最爛的，已更改。

這裡一個重要的注意事項是，我們只優化了一個值，但該值可以是一個數組。 這就是為什麼我們使用w作為變數，而不是兩個單獨的變數a和b。

繪製誤差

這個程式碼是上面的一個小改動。 首先，我們建立一個列表來儲存誤差。然後，在迴圈內部，我們顯式地計算train_op和誤差。 我們在一行中執行此操作，因此誤差僅計算一次。 如果我們在單獨的行中這樣做，它將計算誤差，然後是訓練步驟，並且在這樣做時，它將需要重新計算誤差。

下面我把程式碼放在上一個程式的tf.global_variables_initializer()行下面 - 這一行上面的所有內容都是一樣的。

errors = []
with tf.Session() as session:
    session.run(model)
    for i in range(1000):
        x_train = tf.random_normal((1,), mean=5, stddev=2.0)
        y_train = x_train * 2 + 6
        x_value, y_value = session.run([x_train, y_train])
        _, error_value = session.run([train_op, error], feed_dict={x: x_value, y: y_value})
        errors.append(error_value)
    w_value = session.run(w)
    print("Predicted model: {a:.3f}x + {b:.3f}".format(a=w_value[0], b=w_value[1]))

import matplotlib.pyplot as plt
plt.plot([np.mean(errors[i-50:i]) for i in range(len(errors))])
plt.show()
plt.savefig("errors.png")

你可能已經注意到我在這裡採用視窗平均值 - 使用np.mean(errors[i-50:i])而不是僅使用errors[i]。 這樣做的原因是我們只在迴圈中測試一次，所以雖然誤差會減小，但它會反彈很多。 採用這個視窗平均值可以平滑一點，但正如你在上面所看到的，它仍然會跳躍。

1）建立第 6 課中的 k-means 示例的收斂函式，如果舊質心與新質心之間的距離小於給定的epsilon值，則停止訓練。

2）嘗試從梯度下降示例（w）中分離a和b值。

3）我們的例子一次只訓練一個示例，這是低效的。 擴充套件它來一次使用多個（例如 50 個）訓練樣本來學習。

TFLearn

已更新到最新的 TFLearn API。

這些教程主要關注 TensorFlow 的機制，但真正的用例是機器學習。 TensorFlow 有許多用於構建機器學習模型的方法，其中許多可以在官方 API 頁面上找到。 這些函式允許你從頭開始構建模型，包括自定義層面，例如如何構建神經網路中的層。

在本教程中，我們將檢視 TensorFlow Learn，它是名為skflow的軟體包的新名稱。 TensorFlow Learn（以下簡稱：TFLearn）是一個機器學習包裝器，基於 scikit-learn API，允許你輕鬆執行資料探勘。 這意味著什麼？ 讓我們一步一步地完成它：

機器學習

機器學習是一種概念，構建從資料中學習的演算法，以便對新資料執行操作。 在這種情況下，這意味著我們有一些輸入的訓練資料和預期結果 - 訓練目標。 我們將看看著名的數字資料集，這是一堆手繪數字的影象。 我們的輸入訓練資料是幾千個這些影象，我們的訓練目標是預期的數字。

任務是學習一個模型，可以回答“這是什麼數字？”，對於這樣的輸入：

這是一個分類任務，是資料探勘最常見的應用之一。 還有一些稱為迴歸和聚類的變體（以及許多其他變體），但在本課中我們不會涉及它們。

如果你想了解資料探勘的更多資訊，請檢視我的書“Python 資料探勘”。

Scikit-Learn API

Scikit-learn 是一個用於資料探勘和分析的 Python 包，它非常受歡迎。 這是因為它廣泛支援不同的演算法，令人驚歎的文件，以及龐大而活躍的社群。 其他一個因素是它的一致介面，它的 API，允許人們構建可以使用 scikit-learn 輔助函式訓練的模型，並允許人們非常容易地測試不同的模型。

我們來看看 scikit-learn 的 API，但首先我們需要一些資料。 以下程式碼載入了一組可以使用matplotlib.pyplot顯示的數字影象：

from sklearn.datasets import load_digits
from matplotlib import pyplot as plt


digits = load_digits()

我們可以使用pyplot.imshow顯示其中一個影象。 在這裡，我設定interpolation ='none'來完全按原樣檢視資料，但是如果你刪除這個屬性，它會變得更清晰（也嘗試減小數字大小）。

fig = plt.figure(figsize=(3, 3))

plt.imshow(digits['images'][66], cmap="gray", interpolation='none')

plt.show()

在 scikit-learn 中，我們可以構建一個簡單的分類器，訓練它，然後使用它來預測影象的數字，只需使用四行程式碼：

from sklearn import svm

classifier = svm.SVC(gamma=0.001)
classifier.fit(digits.data, digits.target)
predicted = classifier.predict(digits.data)

第一行只是匯入支援向量機模型，這是一種流行的機器學習方法。

第二行構建“空白”分類器，gamma設定為 0.001。

第三行使用資料來訓練模型。 在這一行（這是該程式碼的大部分“工作”）中，調整 SVM 模型的內部狀態來擬合訓練資料。 我們還傳遞digits.data，因為這是一個展開的陣列，是該演算法的可接受輸入。

最後，最後一行使用這個訓練好的分類器來預測某些資料的類，在這種情況下再次是原始資料集。

要了解這是多麼準確，我們可以使用 NumPy 計算準確度：

import numpy as np
print(np.mean(digits.target == predicted))

結果非常令人印象深刻（近乎完美），但這些有點誤導。 在資料探勘中，你永遠不應該在用於訓練的相同資料上評估你的模型。 潛在的問題被稱為“過擬合”，其中模型準確地學習了訓練資料所需的內容，但是無法很好地預測新的沒見過的資料。 為解決這個問題，我們需要拆分我們的訓練和測試資料：

from sklearn.cross_validation import train_test_split
X_train, X_test, y_train, y_test = train_test_split(digits.data, digits.target)

結果仍然非常好，大約 98%，但這個資料集在資料探勘中是眾所周知的，其特徵已有詳細記錄。 無論如何，我們現在知道我們要做什麼，讓我們在 TFLearn 中實現它！

TFLearn

TensorFlow Learn 介面距離 scikit-learn 的介面只有一小步之遙：

from tensorflow.contrib import learn
n_classes = len(set(y_train))
classifier = learn.LinearClassifier(feature_columns=[tf.contrib.layers.real_valued_column("", dimension=X_train.shape[1])],
                                    n_classes=n_classes)
classifier.fit(X_train, y_train, steps=10)

y_pred = classifier.predict(X_test)

唯一真正的變化是import語句和模型，它來自不同的可用演算法列表。 一個區別是分類器需要知道它將預測多少個類，可以使用len(set(y_train))找到，或者換句話說，訓練資料中有多少個唯一值。

另一個區別是，需要告知分類器預期的特徵型別。 對於這個例子，我們有真正重要的連續特徵，所以我們可以簡單地指定feature_columns值（它需要在列表中）。 如果你使用類別特徵，則需要單獨說明。 這方面的更多資訊，請檢視 TFLearn 示例的文件。

可以像以前一樣評估結果，來計算準確性，但 scikit-learn 有 classification_report，它提供了更深入的瞭解：

from sklearn import metrics
print(metrics.classification_report(y_true=y_test, y_pred=y_pred))

結果顯示每個類的召回率和精度，以及總體值和 f 度量。這些分數比準確性更可靠，更多資訊請參閱維基百科上的此頁面。

這是 TFLearn 的高階概述。你可以定義自定義分類器，你將在練習 3 中看到它們，並將分類器組合到流水線中（對此的支援很小，但正在改進）。該軟體包有可能成為工業和學術界廣泛使用的資料探勘軟體包。

1）將分類器更改為DNNClassifier並重新執行。隨意告訴所有朋友你現在使用深度學習來做資料分析。

2）DNNClassifier的預設引數是好的，但不完美。嘗試更改引數來獲得更高的分數。

3）從 TFLearn 的文件中檢視此示例並下載 CIFAR 10 資料集。構建一個使用卷積神經網路預測影象的分類器。你可以使用此程式碼載入資料：

def load_cifar(file):
    import pickle
    import numpy as np
    with open(file, 'rb') as inf:
        cifar = pickle.load(inf, encoding='latin1')
    data = cifar['data'].reshape((10000, 3
            
  
           

              
              
            
            
相關推薦
			   
            
            
            
 

    

    
    
TensorFlow 學習指南 三、學習
     
  
  
  
  
  原文：LearningTensorFlow.com 
  譯者：飛龍 
  協議：CC BY-NC-SA 4.0 
  自豪地採用谷歌翻譯 
  
 聚類和 KMeans 
 我們現在冒險進入我們的第一個應用，即使用 k-means 演算法進行聚類。 聚類是一種資料探勘練習，我們獲取 

  
 

    

    
    
TensorFlow 學習指南 四、分散式
     
  
  
  
  
  原文：LearningTensorFlow.com 
  譯者：飛龍 
  協議：CC BY-NC-SA 4.0 
  自豪地採用谷歌翻譯 
  
 自定義函式 
 Conway 的生命遊戲是一個有趣的電腦科學模擬，它在地圖上發生，有許多正方形的單元格，就像棋盤一樣。 模擬以特定的時 

  
 

    

    
    
TensorFlow 學習指南 二、線性模型
     
  
  
  
  
  原文：LearningTensorFlow.com 
  譯者：飛龍 
  協議：CC BY-NC-SA 4.0 
  自豪地採用谷歌翻譯 
  
 廣播 
 當我們操作不同維度的陣列時，它們可以以不同的方式組合，無論是逐元素還是通過廣播。 
 讓我們從頭開始，構建更復雜的例子。 在 

  
 

    

    
    
JPA學習（三、JPA_API）
     
 地方   釋放   contain   清除   枚舉   自動   中文名   異常   沒有   框架學習之JPA（三）
JPA是Java Persistence API的簡稱，中文名Java持久層API，是JDK 5.0註解或XML描述對象－關系表的映射關系，並將運行期的實體對象持久化到數據庫中。
Su 

  
 

    

    
    
三、學習筆記，GCC編譯器
     
  
  
  
 
 
  目錄
  
   
    GCC的編譯流程分為以下4個步驟
    GCC所支援不同字尾名的處理方式
    GCC編譯流程語法
    GCC警告提示
   
  
 
  
 GCC的編譯流程分為以下4個步驟 
  
  預處理（pre-processing） 
  編譯（c 

  
 

    

    
    
分享《TensorFlow學習指南：深度學習系統構建詳解》英文PDF+原始碼+部分中文PDF
     
 下載：https://pan.baidu.com/s/1v4B-Jp-lQClBWiCfDd1_dw 
更多分享：http://blog.51cto.com/14050756 
《TensorFlow學習指南：深度學習系統構建詳解》英文PDF+原始碼+部分中文PDF英文完整版PDF，242頁，帶目錄書籤，彩色 

  
 

    

    
    
《TensorFlow學習指南：深度學習系統構建詳解》英文PDF+原始碼+部分中文PDF
     
 下載：https://pan.baidu.com/s/1v4B-Jp-lQClBWiCfDd1_dw 
更多資料：https://pan.baidu.com/s/1g4hv05UZ_w92uh9NNNkCaA 
《TensorFlow學習指南：深度學習系統構建詳解》英文PDF+原始碼+部分中文PDF英文完整版 

  
 

    

    
    
分享《TensorFlow學習指南：深度學習系統構建詳解》英文PDF+源代碼+部分中文PDF
     
 size   分布式   部署   模型   -o   卷積神經網絡   ref   ima   源代碼   下載：https://pan.baidu.com/s/1v4B-Jp-lQClBWiCfDd1_dw
更多分享：http://blog.51cto.com/14050756
《TensorFlow學習 

  
 

    

    
    
MySQL學習（三、分組查詢和多表查詢）
     
 
                一、分組查詢1.MySQL查詢函式    函式的分類：    1，單行函式：將每條資料進行獨立的計算，然後每條資料得到一條結果。    2，多行函式：多條資料同時計算，最終得到一條結果資料。也成為聚集函式、分組函式， 主要用於完成一些統計功能。2.什麼是分組？    針對於班 

  
 

    

    
    
Mongodb學習筆記三、使用asp.net在Mongodb中儲存和讀取圖片檔案
     
 
                
今天練習瞭如何使用c# driver儲存和讀取圖片。

廢話不多說，直接上程式碼。
一、儲存圖片（檔案應該也一樣）：

        private void SaveImgBJSON(string id, byte[] byteImg)
        {
       

  
 

    

    
    
JDBC學習（三、DDL、DML和DQL）
     
 
                 一、DDL操作    我們來建立一張學生表，欄位我們給id,name,age，要求id主鍵，自增程式碼演示：package sql;

import java.sql.Connection;
import java.sql.DriverManager;
import jav 

  
 

    

    
    
TensorFlow 學習指南：深度學習系統構建詳解
     
  
 
 內容簡介
 面向廣泛的技術受眾（從資料科學家、工程師到學生和研究人員），本書介紹了 TensorFlow 的基本原理和實踐方法。從 TensorFlow 中的一些基本示例開始，深入探討諸如神經網路體系結構、TensorBoard 視覺化、TensorFlow 抽象庫和多執行緒輸入管道等主題。閱讀本書 

  
 

    

    
    
Vue.js基礎學習（三、Class 與 Style 繫結）
     
  
  
  
 
 
  Class 與 Style 繫結
  
   Class 與 Style 繫結
   
    1.建立一個 Vue 例項
    
     1.1 物件語法
     1.2 陣列語法
     1.3 用在元件上
    
    2.繫結內聯樣式
    
     2.1 

  
 

    

    
    
深入理解Java虛擬機器學習筆記——三、虛擬機器類載入機制
     
 
                
1、概述
虛擬機器把描述類的資料從Class檔案載入到記憶體，並對資料進行校驗、轉換解析和初始化，最終形成能夠被虛擬機器直接使用的資料型別，這就是虛擬機器的類載入機制。在Java中，類的載入、校驗、解析和初始化都是在執行期間完成的。
2、類載入的時機
類從被載入都虛擬機器記 

  
 

    

    
    
Dubbo原始碼學習（三、服務暴露ServiceBean）
     
 
                堅持一下，把原始碼看完，勤奮一點，不要在懶惰了，你已經落下別人很多了

環境配置:

jdk  1.7.0.17
dubbo 2.5.x
myeclipse 2014
idea 2017

ServiceBean  是針對<dubbo:service />標籤解析 

  
 

    

    
    
Python.CVXPY學習指南三
     
 
							
							
							凸問題的程式設計規則(Disciplined Convex Programming) 
  前言：DCP(Disciplined convex programming )是一個系統，它從已給的基礎函式庫構造已知曲率的數學表示式。CVXPY使用DCP確保目標函式為 

  
 

    

    
    
python學習筆記(三)、字典
     
 映射類型   strong   賦值   python學習   兩個   4.3   所有   tde   及其   　　字典是一種映射類型的數據類型。辣麽什麽是映射呢？如果看過《數據結構與算法》這一本書的小夥伴應該有印象(我也只是大學學習過，嘻嘻)。
　　映射：就是將兩個集合一 一對應起來，通過集合a的值 

  
 

    

    
    
【tensorflow:Google】三、tensorflow入門
     
 als   管理   神經網絡   等價   問題   sign   ria   init   節點   【一】計算圖模型
節點是計算，邊是數據流，
a = tf.constant( [1., 2.] )定義的是節點，節點有屬性 a.graph 
取得默認計算圖　　g1 = tf.get_default_gr 

  
 

    

    
    
機器學習 | 吳恩達機器學習第三週學習筆記
     
 
                

第三週PPT彙總下載連結:https://pan.baidu.com/s/101uY5KV_2i3Ey516DYma_A  密碼:8o4e

上一篇部落格主要介紹了第二週的課程的內容，包括多變數線性迴歸，使用梯度下降法求解多變數線性迴歸的實用技巧，特徵縮放與模型特徵選擇並 

  
 

    

    
    
Python入門學習指南--內附學習框架
     
 手動   下載   標準   我們   python編程   key   學習指南   外星人入侵   flask   Python入門學習指南

最近開始整理python的資料，博主建立了一個qq群，希望給大家提供一個交流的同平臺: 78486745 ,歡迎大家加入共同交流學習。


對於初學者，入門至關重