㈠ 如何用python新建一個1至100范圍內的隨機整數數組,其shape為(5,4),命名為data
from random import randint
ar=[[randint(1,100) for _ in range(4)] for _ in range(5)]
print(ar)
㈡ python 如何畫出KD數
簡單的KNN演算法在為每個數據點預測類別時都需要遍歷整個訓練數據集來求解距離，這樣的做法在訓練數據集特別大的時候並不高效，一種改進的方法就是使用kd樹來存儲訓練數據集，這樣可以使KNN分類器更高效。
KD樹的主要思想跟二叉樹類似，我們先來回憶一下二叉樹的結構，二叉樹中每個節點可以看成是一個數，當前節點總是比左子樹中每個節點大，比右子樹中每個節點小。而KD樹中每個節點是一個向量(也可能是多個向量)，和二叉樹總是按照數的大小劃分不同的是，KD樹每層需要選定向量中的某一維，然後根據這一維按左小右大的方式劃分數據。在構建KD樹時，關鍵需要解決2個問題：（1）選擇向量的哪一維進行劃分（2）如何劃分數據。第一個問題簡單的解決方法可以是選擇隨機選擇某一維或按順序選擇，但是更好的方法應該是在數據比較分散的那一維進行劃分（分散的程度可以根據方差來衡量）。好的劃分方法可以使構建的樹比較平衡，可以每次選擇中位數來進行劃分，這樣問題2也得到了解決。下面是建立KD樹的Python代碼：
def build_tree(data, dim, depth):
"""
建立KD樹
Parameters
----------
data:numpy.array
需要建樹的數據集
dim:int
數據集特徵的維數
depth:int
當前樹的深度
Returns
-------
tree_node:tree_node namedtuple
樹的跟節點
"""
size = data.shape[0]
if size == 0:
return None
# 確定本層劃分參照的特徵
split_dim = depth % dim
mid = size / 2
# 按照參照的特徵劃分數據集
r_indx = np.argpartition(data[:, split_dim], mid)
data = data[r_indx, :]
left = data[0: mid]
right = data[mid + 1: size]
mid_data = data[mid]
# 分別遞歸建立左右子樹
left = build_tree(left, dim, depth + 1)
right = build_tree(right, dim, depth + 1)
# 返回樹的根節點
return Tree_Node(left=left,
right=right,
data=mid_data,
split_dim=split_dim)
對於一個新來的數據點x，我們需要查找KD樹中距離它最近的節點。KD樹的查找演算法還是和二叉樹查找的演算法類似，但是因為KD樹每次是按照某一特定的維來劃分，所以當從跟節點沿著邊查找到葉節點時候並不能保證當前的葉節點就離x最近，我們還需要回溯並在每個父節點上判斷另一個未查找的子樹是否有可能存在離x更近的點（如何確定的方法我們可以思考二維的時候，以x為原點，當前最小的距離為半徑畫園，看是否與劃分的直線相交，相交則另一個子樹中可能存在更近的點），如果存在就進入子樹查找。
當我們需要查找K個距離x最近的節點時，我們只需要維護一個長度為K的優先隊列保持當前距離x最近的K個點。在回溯時，每次都使用第K短距離來判斷另一個子節點中是否存在更近的節點即可。下面是具體實現的python代碼：
def search_n(cur_node, data, queue, k):
"""
查找K近鄰，最後queue中的k各值就是k近鄰
Parameters
----------
cur_node:tree_node namedtuple
當前樹的跟節點
data:numpy.array
數據
queue:Queue.PriorityQueue
記錄當前k個近鄰，距離大的先輸出
k:int
查找的近鄰個數
"""
# 當前節點為空，直接返回上層節點
if cur_node is None:
return None
if type(data) is not np.array:
data = np.asarray(data)
cur_data = cur_node.data
# 得到左右子節點
left = cur_node.left
right = cur_node.right
# 計算當前節點與數據點的距離
distance = np.sum((data - cur_data) ** 2) ** .5
cur_split_dim = cur_node.split_dim
flag = False # 標記在回溯時是否需要進入另一個子樹查找
# 根據參照的特徵來判斷是先進入左子樹還是右子樹
if data[cur_split_dim] > cur_data[cur_split_dim]:
tmp = right
right = left
left = tmp
# 進入子樹查找
search_n(left, data, queue, k)
# 下面是回溯過程
# 當隊列中沒有k個近鄰時，直接將當前節點入隊，並進入另一個子樹開始查找
if len(queue) < k:
neg_distance = -1 * distance
heapq.heappush(queue, (neg_distance, cur_node))
flag = True
else:
# 得到當前距離數據點第K遠的節點
top_neg_distance, top_node = heapq.heappop(queue)
# 如果當前節點與數據點的距離更小，則更新隊列（當前節點入隊，原第k遠的節點出隊）
if - 1 * top_neg_distance > distance:
top_neg_distance, top_node = -1 * distance, cur_node
heapq.heappush(queue, (top_neg_distance, top_node))
# 判斷另一個子樹內是否可能存在跟數據點的距離比當前第K遠的距離更小的節點
top_neg_distance, top_node = heapq.heappop(queue)
if abs(data[cur_split_dim] - cur_data[cur_split_dim]) < -1 * top_neg_distance:
flag = True
heapq.heappush(queue, (top_neg_distance, top_node))
# 進入另一個子樹搜索
if flag:
search_n(right, data, queue, k)525354555657
以上就是KD樹的Python實踐的全部內容，由於本人剛接觸python不久，可能實現上並不優雅，也可能在演算法理解上存在偏差，如果有任何的錯誤或不足，希望各位賜教。
㈢ 怎樣用python構建一個卷積神經網路
用keras框架較為方便
首先安裝anaconda，然後通過pip安裝keras
㈣ python介面中net.blobs.data.shape 是怎麼調用的
import numpya = numpy.array([[1,2,3],[4,5,6]])print a.shape矩陣有一個shape屬性，是一個(行，列)形式的元組
㈤ python自帶及pandas、numpy數據結構(一)
1.python自帶數據結構：序列（如list）、映射（如字典）、集合（set）。
以下只介紹序列中的list：
創建list：
list1 = []
list1 = [1,2,3,4,5,6,7,8,9] #逗號隔開
list2 = [[1,2],[3,4],[5,6],[7,8]] #list2長度(len(list2))為2,list2[0] = [1,2]
liststring = list(「thisisalist」) #只用於創建字元串列表
索引list：
e = list1[0] #下標從零開始，用中括弧
分片list：
es = list1[0:3]
es = list1[0:9:2] #步長在第二個冒號後
list拼接（list1.append(obj)、加運算及乘運算）：
list長度：
list每個元素乘一個數值：
list2 = numpy.dot(list2,2)
list類似矩陣相乘（每個元素對應相乘取和）：
list3 = numpy.dot(list1,list1)
#要求相乘的兩個list長度相同
list3 = numpy.dot(list2,list22)
#要求numpy.shape(list2)和numpy.shape(list22)滿足「左行等於右列」的矩陣相乘條件，相乘結果numpy.shape(list3)滿足「左列右行」
2.numpy數據結構：
Array：
產生array：
data=np.array([[1, 9, 6], [2, 8, 5], [3, 7, 4]])
data=np.array(list1)
data1 = np.zeros(5) #data1.shape = (5,),5列
data1 = np.eye(5)
索引array:
datacut = data[0,2] #取第零行第二列，此處是6
切片array：
datacut = data[0:2,2] # array([6, 5])
array長度：
data.shape
data.size
np.shape(data)
np.size(data)
len(data)
array拼接：
#括弧內也有一個括弧（中括弧或者小括弧）！
d = np.concatenate((data,data))
d = np.concatenate((data,data),axis = 1) #對應行拼接
array加法：逐個相加
array乘法：
d = data data #逐個相乘
d = np.dot(data,data) #矩陣相乘
d = data 3 #每個元素乘3
d = np.dot(data,3) #每個元素乘3
array矩陣運算：
取逆 : np.linalg.inv(data)
轉置：data.T
所有元素求和 : np.sum(data)
生成隨機數：np.random.normal(loc=0, scale=10, size=None)
生成標准正態分布隨機數組：np.random.normal(size=(4,4))
生成二維隨機數組：
np.random.multivariate_normal([0,0],np.eye(2))
生成范圍在0到1之間的隨機矩陣(M,N)：
np.random.randint(0,2,(M,N))
Matrix:
創建matrix：
mat1 = np.mat([[1, 2, 3], [4, 5, 6]])
mat1 = np.mat(list)
mat1 = np.mat(data)
matrix是二維的，所有+，-，*都是矩陣操作。
matrix索引和分列：
mat1[0:2，1]
matrix轉置：
np.transpose(mat1)
mat1.transpose()
matrix拼接：
np.concatenate([mat1,mat1])
np.concatenate([mat1,mat1],axis = 1)
numpy數據結構總結：對於numpy中的數據結構的操作方法基本相同：
創建：np.mat(list),np.array(list)
矩陣乘：np.dot(x,y)
轉置：x.T or np.transpose(x)
拼接：np.concatenate([x,y],axis = 1)
索引：mat[0:1,4],ary[0:1,4]
3.pandas數據結構:
Series:
創建series：
s = pd.Series([[1,2,3],[4,5,6]],index = [『a』,『b』])
索引series：
s1 = s[『b』]
拼接series：
pd.concat([s1,s1],axis = 1) #也可使用s.append(s)
DataFrame:
創建DaraFrame:
df = pd.DataFrame([[1,2,3],[1,2,3]],index = ['a','b'],columns = ['x','y','z'])
df取某一列：
dfc1 =df.x
dfc1 = df[『x』]
dfc2 = df.iloc[:,0] #用.iloc方括弧里是數字而不是column名！
dfc2 = df.iloc[:,0:3]
df取某一行：
dfr1 = df.iloc[0]
df1 = df.iloc[0:2]
df1 = df[0:2] #這種方法只能用於取一個區間
df取某個值：
dfc2 = df.iloc[0,0]
dfc2 = df.iloc[0:2,0:3]
㈥ PYTHON實現對CSV文件多維不同單位數據的歸一化處理
1）線性歸一化
這種歸一化比較適用在數值比較集中的情況，缺陷就是如果max和min不穩定，很容易使得歸一化結果不穩定，使得後續的效果不穩定，實際使用中可以用經驗常量來代替max和min。
2）標准差標准化
經過處理的數據符合標准正態分布，即均值為0，標准差為1。
3）非線性歸一化
經常用在數據分化較大的場景，有些數值大，有些很小。通過一些數學函數，將原始值進行映射。該方法包括log、指數、反正切等。需要根據數據分布的情況，決定非線性函數的曲線。
log函數：x = lg(x)/lg(max)
反正切函數：x = atan(x)*2/pi
Python實現
線性歸一化
定義數組：x = numpy.array(x)
獲取二維數組列方向的最大值：x.max(axis = 0)
獲取二維數組列方向的最小值：x.min(axis = 0)
對二維數組進行線性歸一化：
def max_min_normalization(data_value, data_col_max_values, data_col_min_values):
""" Data normalization using max value and min value
Args:
data_value: The data to be normalized
data_col_max_values: The maximum value of data's columns
data_col_min_values: The minimum value of data's columns
"""
data_shape = data_value.shape
data_rows = data_shape[0]
data_cols = data_shape[1]
for i in xrange(0, data_rows, 1):
for j in xrange(0, data_cols, 1):
data_value[i][j] = \
(data_value[i][j] - data_col_min_values[j]) / \
(data_col_max_values[j] - data_col_min_values[j])
標准差歸一化
定義數組：x = numpy.array(x)
獲取二維數組列方向的均值：x.mean(axis = 0)
獲取二維數組列方向的標准差：x.std(axis = 0)
對二維數組進行標准差歸一化：
def standard_deviation_normalization(data_value, data_col_means,
data_col_standard_deviation):
""" Data normalization using standard deviation
Args:
data_value: The data to be normalized
data_col_means: The means of data's columns
data_col_standard_deviation: The variance of data's columns
"""
data_shape = data_value.shape
data_rows = data_shape[0]
data_cols = data_shape[1]
for i in xrange(0, data_rows, 1):
for j in xrange(0, data_cols, 1):
data_value[i][j] = \
(data_value[i][j] - data_col_means[j]) / \
data_col_standard_deviation[j]
非線性歸一化（以lg為例）
定義數組：x = numpy.array(x)
獲取二維數組列方向的最大值：x.max(axis=0)
獲取二維數組每個元素的lg值：numpy.log10(x)
獲取二維數組列方向的最大值的lg值：numpy.log10(x.max(axis=0))
對二維數組使用lg進行非線性歸一化：
def nonlinearity_normalization_lg(data_value_after_lg,
data_col_max_values_after_lg):
""" Data normalization using lg
Args:
data_value_after_lg: The data to be normalized
data_col_max_values_after_lg: The maximum value of data's columns
"""
data_shape = data_value_after_lg.shape
data_rows = data_shape[0]
data_cols = data_shape[1]
for i in xrange(0, data_rows, 1):
for j in xrange(0, data_cols, 1):
data_value_after_lg[i][j] = \
data_value_after_lg[i][j] / data_col_max_values_after_lg[j]
㈦ Python對數據進行排序-中英文
sort_values(by,axis=0,ascending=True,inplace=False,kind='quicksort',na_position='last')
參數說明：
by: 可以填入字元串或者字元串組成的列表。也就是說， 如果axis=0，那麼by="列名"；如果axis=1，那麼by="行名"。
axis: {0 or 『index』, 1 or 『columns』}, default 0，意思就是如果 axis=0，就按照索引排序，即縱向排序；如果axis=1，則按列排序，即橫向排序。默認是axis=0 。
ascending: 輸入布爾型， True是升序 ， False是降序 ，也可以可以是[True,False]，即第一個欄位升序，第二個欄位降序 。
inplace : 輸入布爾型，是否用排序後的數據框替換現有的數據框
kind: 排序的方法，{『quicksort』, 『mergesort』, 『heapsort』}，默認是使用『quicksort』。這個參數用的比較少，大家可以試一試。
na_position : {『first』, 『last』}， 缺失值的排序 ，也就說決定將缺失值放在數據的最前面還是最後面 。first是排在前面，last是排在後面，默認是用last 。
例子：
scores= pd.DataFrame([[87,56,85],[46,87,97],[34,65,86]],columns=['jack', 'rose', 'mike'])
scores
1.對『rose』這一列進行降序排序：
df_sc=scores.sort_values(by='rose',ascending=False)
df_sc
2.對第0行進行升序排序：
scores.sort_values(by=0,axis=1,ascending=True)
3.第1行進行升序，第0行進行降序：
scores.sort_values(by=[1,0],axis=1,ascending=[True,False]
4.觀察數據
data.head：
查看數據的前五行。
data.tail：
查看數據的後五行。
data.shape ：
查看矩陣或數組的維數，或者是說數據表的結構（有幾行幾列）。
data.info ：
查看數據的基本信息，如：數據類型、缺失值數量等。
#brand目標：中文-中英-英文
2.1 包含中文，純英文
for i in range(0,len(file1)):
result = re.compile(u'[\u4e00-\u9fa5]')
contents = file1['brand'][i]
match = result.search(contents)
if match:
file1.loc[i,['index1']]=0 #0為包含中文
else:
file1.loc[i,['index1']]=1 #1為純英文
2.1 包含英文，純中文
for i in range(0,len(file1)):
file1.loc[i,['index2']]=len(re.findall('[a-zA-Z]+', file1['brand'][i]) ) #0為純中文，1為包含英文
㈧ 如何使用Python工具分析風險數據
1、引入工具–載入數據分析包
啟動IPython notebook，載入運行環境：
%matplotlib inline
import pandas as pd
from datetime import timedelta, datetime
import matplotlib.pyplot as plt
import numpy as np
2、數據准備
俗話說: 巧婦難為無米之炊。小安分析的數據主要是用戶使用代理IP訪問日誌記錄信息，要分析的原始數據以CSV的形式存儲。這里首先要介紹到pandas.read_csv這個常用的方法，它將數據讀入DataFrame
analysis_data = pd.read_csv('./honeypot_data.csv')
對的, 一行代碼就可以將全部數據讀到一個二維的表結構DataFrame變數，感覺很簡單有木有啊!!!當然了用Pandas提供的IO工具你也可以將大文件分塊讀取，再此小安測試了一下性能，完整載入約21530000萬條數據也大概只需要90秒左右，性能還是相當不錯。
3、數據管窺
一般來講，分析數據之前我們首先要對數據有一個大體上的了解，比如數據總量有多少，數據有哪些變數，數據變數的分布情況，數據重復情況，數據缺失情況，數據中異常值初步觀測等等。下面小安帶小夥伴們一起來管窺管窺這些數據。
使用shape方法查看數據行數及列數
analysis_data.shape
Out: (21524530, 22) #這是有22個維度，共計21524530條數據記的DataFrame
使用head()方法默認查看前5行數據，另外還有tail()方法是默認查看後5行,當然可以輸入參數來查看自定義行數
analysis_data.head(10)
這里可以了解到我們數據記錄有用戶使用代理IP日期，代理header信息，代理訪問域名，代理方法，源ip以及蜜罐節點信息等等。在此小安一定一定要告訴你，小安每次做數據分析時必定使用的方法–describe方法。pandas的describe()函數能對數據進行快速統計匯總：
對於數值類型數據，它會計算出每個變數： 總個數，平均值，最大值，最小值，標准差，50%分位數等等;
非數值類型數據，該方法會給出變數的： 非空值數量、unique數量(等同於資料庫中distinct方法)、最大頻數變數和最大頻數。
由head()方法我們可以發現數據中包含了數值變數、非數值變數，我們首先可以利用dtypes方法查看DataFrame中各列的數據類型，用select_dtypes方法將數據按數據類型進行分類。然後，利用describe方法返回的統計值對數據有個初步的了解：
df.select_dtypes(include=['O']).describe()
df.select_dtypes(include=['float64']).describe()
簡單的觀察上面變數每一維度統計結果，我們可以了解到大家獲取代理數據的長度平均1670個位元組左右。同時，也能發現欄位scanossubfp，scanscan_mode等存在空值等等信息。這樣我們能對數據整體上有了一個大概了解。
4、數據清洗
由於源數據通常包含一些空值甚至空列，會影響數據分析的時間和效率，在預覽了數據摘要後，需要對這些無效數據進行處理。
一般來說，移除一些空值數據可以使用dropna方法， 當你使用該方法後，檢查時發現 dropna() 之後幾乎移除了所有行的數據，一查Pandas用戶手冊，原來不加參數的情況下， dropna() 會移除所有包含空值的行。
如果你只想移除全部為空值的列，需要加上 axis 和 how 兩個參數：
analysis_data.dropna(axis=1, how='all')
另外，也可以通過dropna的參數subset移除指定列為空的數據，和設置thresh值取移除每非None數據個數小於thresh的行。
analysis_data.dropna(subset=['proxy_host', 'srcip'])
#移除proxy_host欄位或srcip欄位沒有值的行
analysis_data.dropna(thresh=10)
#移除所有行欄位中有值屬性小於10的行
5、統計分析
再對數據中的一些信息有了初步了解過後，原始數據有22個變數。從分析目的出發，我將從原始數據中挑選出局部變數進行分析。這里就要給大家介紹pandas的數據切片方法loc。
loc([startrowindex:endrowindex,[『timestampe』, 『proxy_host』, 『srcip』]])是pandas重要的切片方法，逗號前面是對行進行切片;逗號後的為列切片，也就是挑選要分析的變數。
如下，我這里選出日期，host和源IP欄位——
analysis_data = analysis_data.loc([:, [『timestampe』,'proxy_host','srcip']])
首先讓我們來看看蜜罐代理每日使用數據量，我們將數據按日統計，了解每日數據量PV，並將結果畫出趨勢圖。
daily_proxy_data = analysis_data[analysis_data.mole=='proxy']
daily_proxy_visited_count = daily_proxy_data.timestamp.value_counts().sort_index()
daily_proxy_visited_count.plot()
對數據列的丟棄，除無效值和需求規定之外，一些表自身的冗餘列也需要在這個環節清理，比如說DataFrame中的index號、類型描述等，通過對這些數據的丟棄，從而生成新的數據，能使數據容量得到有效的縮減，進而提高計算效率。
由上圖分析可知蜜罐代理使用量在6月5號，19-22號和25號這幾天呈爆炸式增長。那麼這幾天數據有情況，不正常，具體是神馬情況，不急，後面小安帶大家一起來慢慢揪出來到底是那些人(源ip) 幹了什麼「壞事」。
進一步分析, 數據有異常後，再讓我們來看看每天去重IP數據後量及其增長量。可以按天groupby後通過nunique()方法直接算出來每日去重IP數據量。
daily_proxy_data = analysis_data[analysis_data.mole=='proxy']
daily_proxy_visited_count = daily_proxy_data.groupby(['proxy_host']).srcip.nunique()
daily_proxy_visited_count.plot()
究竟大部分人(源ip)在干神馬?干神馬?干神馬?讓我們來看看被訪問次數最多host的哪些，即同一個host關聯的IP個數，為了方便我們只查看前10名熱門host。
先選出host和ip欄位，能過groupby方法來group 每個域名(host)，再對每個域名的ip訪問里unique統計。
host_associate_ip = proxy_data.loc[:, ['proxy_host', 'srcip']]
grouped_host_ip = host_associate_ip.groupby(['proxy_host']).srcip.nunique()
print(grouped_host_ip.sort_values(ascending=False).head(10))
再細細去看大家到底做了啥——查看日誌數據發現原來在收集像二手車價格，工人招聘等等信息。從熱門host來看，總得來說大家使用代理主要還是獲取網路，qq，Google，Bing這類婦孺皆知網站的信息。
下面再讓我們來看看是誰用代理IP「幹事」最多，也就是看看誰的IP訪問不同host的個數最多。
host_associate_ip = proxy_data.loc[:, ['proxy_host', 'srcip']]
grouped_host_ip = host_associate_ip.groupby(['srcip'_host']).proxy_host.nunique()
print(grouped_host_ip.sort_values(ascending=False).head(10))
哦，發現目標IP為123..*.155的小夥子有大量訪問記錄, 進而查看日誌，原來他在大量收集酒店信息。 好了，這樣我們就大概能知道誰在干什麼了，再讓我們來看看他們使用proxy持續時長，誰在長時間里使用proxy。 代碼如下——
這里不給大家細說代碼了，只給出如下偽代碼。
date_ip = analysis_data.loc[:,['timestamp','srcip']]
grouped_date_ip = date_ip.groupby(['timestamp', 'srcip'])
#計算每個源ip(srcip)的訪問日期
all_srcip_ration_times = ...
#算出最長連續日期天數
ration_date_cnt = count_date(all_srcip_ration_times)
好了，到此我也就初略的知道那些人做什麼，誰用代理時長最長等等問題額。取出ip = 80...38的用戶使用代理ip訪問數據日誌，發現原來這個小夥子在長時間獲取搜狐images。
蜜罐在全國各地部署多個節點，再讓我們來看看每個源ip掃描蜜罐節點總個數，了解IP掃描節點覆蓋率。結果見如下：
# 每個IP掃描的IP掃描節點總個數
node = df[df.mole=='scan']
node = node.loc[:,['srcip','origin_details']]
grouped_node_count = node.groupby(['srcip']).count()
print grouped_node_count.sort_values(['origin_details'], ascending=False).head(10)
由上述兩表初步可知，一些結論：如源ip為182...205的用戶長時間對蜜罐節點進行掃描，mark危險用戶等等。