Python数据整合与数据准备-BigGorilla实例应用
参考文档：http://www.biggorilla.org/walkt/
一、BigGorilla应用主要步骤
如下图：
二、实例应用
1、数据获取
urllib是非常受欢迎的用于在网络上读取数据的Python软件包。在本部分中，我们使用urllib下载本教程所需的数据集。
“Kaggle 5000 Movie Dataset”下载 所需的数据集是一个.csv文件，拥有以下代码片段中指定的url。
2、数据抽取
“Kaggle 5000 Movie Dataset”存储在.csv文件中，该文件已经完成结构化并且可供使用。另一方面，“IMDB Plain Text Data”是一系列需要进行处理以抽取数据的半结构化文本文件。快速查看每个文件的前几行可以发现，每个文件都有不同的格式，
并且必须单独加以处理。
3、数据归档和清理
在此数据准备阶段中的高级目标就是审视我们目前已经获取和抽取的数据。这样可以帮助我们熟悉数据，了解数据需要以什么方式进行清理或转换，最终让我们为数据整合任务的以下步骤准备数据。
a、处理重复（清理）
# 使用简单的重复处理方法，即仅保留第一次出现的重复条目并移除剩余的重复条目
b、文本标准化（清理）
我们将用来整合电影数据集的关键属性是电影片名。因此，对这些片名进行标准化非常重要。以下代码片段使所有电影片名变为小写，然后移除某些字符，例如“’”和“?”，并替换一些其他特殊字符（例如“&”被替换为“and”）。
4、数据匹配和合并
使用Magellan进行数据匹配
a、寻找一个候选集（拦截）
本步骤的目标是使用简单的启发式规则限制我们认为是潜在匹配的配对数量。对于此任务，我们可以在各个数据集中新建一列，将重要属性的值合并到单个字符串（我们称之为混合）。然后，我们可以像之前一样使用字符串类似项合并，
寻找重要列的数值有一些重叠的条目组合。在此之前，我们需要将作为混合的一部分的列转换为字符串。使用py_stringsimjoin程序包，我们可以轻松完成这些工作。
现在，我们可以使用混合列创建所需的候选集（我们称之为C）。
b、指定要素
下一步就是指定在py_entitymatching程序包中哪些列对应于各个数据帧中的要素。此外，我们需要指定哪些列对应于候选集中两个数据帧中的外部要素。
c、拦截工具故障排除
d、从候选集采样,label列
e、机器学习算法训练
f、评估匹配质量
g、使用训练的模型匹配数据集
三、完整代码
#coding=utf8
#公共方法 class CommonM: # @classmethod
@staticmethod
def preprocess_title(title):
'''字符串特殊字符处理'''
title = title.lower()
title = title.replace(',', ' ')
title = title.replace("'", '')
title = title.replace('&', 'and')
title = title.replace('?', '')
title = title.decode('utf-8', 'ignore')
return title.strip() ############################################################
#coding=utf8
#数据获取 # Importing urlib
import urllib
import os
import gzip class acquireData:
'''该类主要是获取各种类型的文件''' def __init__(self):
pass def down_csv_data(self):
'''获取csv文件'''
# Creating the data folder
if not os.path.exists('./data'):
os.makedirs('./data') # Obtaining the dataset using the url that hosts it
kaggle_url = 'https://github.com/sundeepblue/movie_rating_prediction/raw/master/movie_metadata.csv'
if not os.path.exists('./data/kaggle_dataset.csv'): # avoid downloading if the file exists
response = urllib.urlretrieve(kaggle_url, './data/kaggle_dataset.csv') imdb_url = 'https://anaconda.org/BigGorilla/datasets/1/download/imdb_dataset.csv'
if not os.path.exists('./data/imdb_dataset.csv'): # avoid downloading if the file exists
response = urllib.urlretrieve(imdb_url, './data/imdb_dataset.csv') def get_gz_data(self):
'''获取gz数据
IMDB Plain Text Data（参见此处）是一系列文件，其中每个文件描述电影的一个或多个属性。我们将重点关注电影属性的子集，它表示我们仅对以下所列文件中的数个文件感兴趣：
genres.list.gz
ratings.list.gz
** 注意： 上述文件的总大小约为30M。 运行以下代码可能需要几分钟时间。
''' # Obtaining IMDB's text files
imdb_url_prefix = 'ftp://ftp.funet.fi/pub/mirrors/ftp.imdb.com/pub/'
imdb_files_list = ['genres.list.gz', 'ratings.list.gz']
# imdb_files_list = ['genres.list.gz']
for name in imdb_files_list:
if not os.path.exists('./data/' + name):
response = urllib.urlretrieve(imdb_url_prefix + name, './data/' + name)
urllib.urlcleanup() # urllib fails to download two files from a ftp source. This fixes the bug!
with gzip.open('./data/' + name) as comp_file, open('./data/' + name[:-3], 'w') as reg_file:
file_content = comp_file.read()
reg_file.write(file_content) # obj = acquireData()
# obj.down_csv_data()
################################################################################################### #coding=utf8
#数据匹配和合并 import os
import datetime
import time
import re
import csv
import pandas as pd
from os import walk
import urllib
import py_stringsimjoin as ssj
import py_stringmatching as sm from pandas.core.frame import DataFrame
from extract_clean import extract_clean_data
import py_entitymatching as em
import LogFile class match_merge_data:
def __init__(self):
pass def WriteToCsv(self, titls, data,filename='./data/finalResult-Magellan.csv'): # csvfile = os.path.join(os.getcwd(), 'csvtest.csv')
with open(filename, 'wb') as f:
writer = csv.writer(f)
# 标题
writer.writerow(titls)
for item in data:
# 内容
writer.writerow(item) def match_merge_list(self):
'''数据匹配合并'''
obj = extract_clean_data()
genreslist = obj.extract_genreslist()
ratinglist = obj.extract_ratinglist()
print ratinglist.shape[0]
print genreslist.shape[0]
brief_imdb_data = pd.merge(ratinglist, genreslist, how='inner', on=['norm_movie', 'year'])
brief_imdb_data.head()
print brief_imdb_data.shape[0] def match_merge_Kaggle_IMDB(self):
'''数据匹配合并'''
obj = extract_clean_data()
kaggle_data = obj.extract_kaggle_dataset()
imdb_data = obj.extract_imdb_dataset()
# print kaggle_data.shape[0] #4919
# print imdb_data.shape[0] #869178
# 方法1
data_attempt1 = pd.merge(imdb_data, kaggle_data, how='inner', left_on=['norm_title', 'norm_year'],
right_on=['norm_movie_title', 'norm_title_year'])
# print data_attempt1.shape[0] #4261
data_attempt1.to_csv('./data/finalResult-IMDB.csv') def match_merge_Kaggle_IMDB_stringsimjoin(self):
'''数据匹配合并'''
obj = extract_clean_data()
kaggle_data = obj.extract_kaggle_dataset()
imdb_data = obj.extract_imdb_dataset() # 方法2
imdb_data['id'] = range(imdb_data.shape[0])
kaggle_data['id'] = range(kaggle_data.shape[0])
#使用编辑距离度量来连接两个表。从左表和右表找到元组，使编辑连接属性之间的距离满足输入条件阈
#。 例如，如果比较运算符是'<='，则找到元组对，其编码距离是字符串之间的值连接属性小于或等于输入阈值，as在“阈值”中指定。
similar_titles = ssj.edit_distance_join(imdb_data, kaggle_data, 'id', 'id', 'norm_title',
'norm_movie_title', l_out_attrs=['title','norm_title', 'norm_year'],
r_out_attrs=['movie_title','norm_movie_title', 'norm_title_year'], threshold=1)
# selecting the entries that have the same production year
data_attempt2 = similar_titles[similar_titles.r_norm_title_year == similar_titles.l_norm_year]
data_attempt2.to_csv('./data/finalResult-stringsimjoin.csv')
# data_attempt2.to_csv('./data/finalResult-stringsimjoin.csv', encoding='utf-8')
# print data_attempt2.shape[0]#4696
# print data_attempt3.shape[0] # 10525 def match_merge_Kaggle_IMDB_Magellan(self):
# print str(datetime.datetime.now())[0:19]
'''数据匹配合并'''
obj = extract_clean_data()
kaggle_data = obj.extract_kaggle_dataset()
imdb_data = obj.extract_imdb_dataset() imdb_data['id'] = range(imdb_data.shape[0])
kaggle_data['id'] = range(kaggle_data.shape[0]) # 方法3
# 子步骤A: 寻找一个候选集（拦截）
# repeating the same thing for the Kaggle dataset
ssj.dataframe_column_to_str(kaggle_data, 'budget', inplace=True)
kaggle_data['mixture'] = kaggle_data['norm_movie_title'] + ' ' + kaggle_data['norm_title_year'] + kaggle_data['budget'] # transforming the "budget" column into string and creating a new **mixture** column
ssj.dataframe_column_to_str(imdb_data, 'budget', inplace=True)
imdb_data['mixture'] = imdb_data['norm_title'] + ' ' + imdb_data['norm_year'] + ' ' + imdb_data['budget'] #使用重叠系数连接两个表。
C = ssj.overlap_coefficient_join(kaggle_data, imdb_data, 'id', 'id', 'mixture', 'mixture',
sm.WhitespaceTokenizer(),
l_out_attrs=['movie_title','norm_movie_title', 'norm_title_year', 'duration',
'budget', 'content_rating'],
r_out_attrs=['title','norm_title', 'norm_year', 'length', 'budget', 'mpaa'],
threshold=0.65)
# C.shape()
rowCount = C.shape[0] #
# print C.shape[0] # 子步骤B: 指定要素
em.set_key(kaggle_data, 'id') # specifying the key column in the kaggle dataset
em.set_key(imdb_data, 'id') # specifying the key column in the imdb dataset
em.set_key(C, '_id') # specifying the key in the candidate set
em.set_ltable(C, kaggle_data) # specifying the left table
em.set_rtable(C, imdb_data) # specifying the right table
em.set_fk_rtable(C, 'r_id') # specifying the column that matches the key in the right table
em.set_fk_ltable(C, 'l_id') # 子步骤C: 拦截工具故障排除
C[['l_norm_movie_title', 'r_norm_title', 'l_norm_title_year', 'r_norm_year',
'l_budget', 'r_budget', 'l_content_rating', 'r_mpaa']].head() # 子步骤D: 从候选集采样,label列
# samplelen = rowCount
sampled = C.sample(rowCount, random_state=0) #增加label列
# 为了标记抽样的数据，我们可以在.csv文件中创建一个新的列（我们称之为label）；
# 如果配对是正确的匹配，则在此栏中填入数值1，否则，填入数值0。为避免文件重叠，让我们将新文件重命名为labeled.csv。
list =[]
for index in xrange(len(sampled.values)): tem =float(sampled.values[index][13])
if tem>0.6:
list.append(1)
else:
list.append(0)
sampled['label'] =list #把采样数据保存到sampled.csv文件里面
# sampled.to_csv('./data/sampled.csv', encoding='utf-8')
sampled.to_csv('./data/sampled.csv') # If you would like to avoid labeling the pairs for now, you can download the labled.csv file from
# BigGorilla using the following command (if you prefer to do it yourself, command the next line)
# response = urllib.urlretrieve('https://anaconda.org/BigGorilla/datasets/1/download/labeled.csv',
# './data/labeled.csv')
labeled = em.read_csv_metadata('data/labeled.csv', ltable=kaggle_data, rtable=imdb_data,
fk_ltable='l_id', fk_rtable='r_id', key='_id')
# tt = labeled.head() # 子步骤E: 机器学习算法训练
# 现在我们可以使用抽样的数据集，针对我们的预测任务进行各种机器学习算法训练。
# 为此，我们需要将我们的数据集分割为训练和测试集，然后为我们的预测任务选择所需的机器学习方法。
split = em.split_train_test(labeled, train_proportion=0.5, random_state=0)
train_data = split['train']
test_data = split['test'] dt = em.DTMatcher(name='DecisionTree', random_state=0)
svm = em.SVMMatcher(name='SVM', random_state=0)
rf = em.RFMatcher(name='RF', random_state=0)
lg = em.LogRegMatcher(name='LogReg', random_state=0)
ln = em.LinRegMatcher(name='LinReg')
nb = em.NBMatcher(name='NaiveBayes') # 在应用任何机器学习方法之前，我们需要抽取一组功能。幸运地是，一旦我们指定两个数据集中的哪些列相互对应，
# py_entitymatching程序包就可以自动抽取一组功能。指定两个数据集的列之间的对应性，
# 将启动以下代码片段。然后，它使用py_entitymatching程序包确定各列的类型。
# 通过考虑（变量l_attr_types和r_attr_types中存储的）各个数据集中列的类型，
# 并使用软件包推荐的编译器和类似功能，我们可以抽取一组用于抽取功能的说明。
# 请注意，变量F并非所抽取功能的集合，相反，它会对说明编码以处理功能。
attr_corres = em.get_attr_corres(kaggle_data, imdb_data)
attr_corres['corres'] = [('norm_movie_title', 'norm_title'),
('norm_title_year', 'norm_year'),
('content_rating', 'mpaa'),
('budget', 'budget'),
] l_attr_types = em.get_attr_types(kaggle_data)
r_attr_types = em.get_attr_types(imdb_data) tok = em.get_tokenizers_for_matching()
sim = em.get_sim_funs_for_matching() F = em.get_features(kaggle_data, imdb_data, l_attr_types, r_attr_types, attr_corres, tok, sim) # 考虑所需功能的集合F，现在我们可以计算训练数据的功能值，并找出我们数据中丢失数值的原因。
# 在这种情况下，我们选择将丢失值替换为列的平均值。 train_features = em.extract_feature_vecs(train_data, feature_table=F, attrs_after='label', show_progress=False)
train_features = em.impute_table(train_features, exclude_attrs=['_id', 'l_id', 'r_id', 'label'],
strategy='mean') # 使用计算的功能，我们可以评估不同机器学习算法的性能，并为我们的匹配任务选择最佳的算法 result = em.select_matcher([ ln, lg,svm,nb,rf, dt], table=train_features,
exclude_attrs=['_id', 'l_id', 'r_id', 'label'], k=5,
target_attr='label', metric='f1', random_state=0)
print result['cv_stats'] # 子步骤F: 评估我们的匹配质量 best_model = result['selected_matcher'] best_model.fit(table=train_features, exclude_attrs=['_id', 'l_id', 'r_id', 'label'], target_attr='label') test_features = em.extract_feature_vecs(test_data, feature_table=F, attrs_after='label', show_progress=False)
test_features = em.impute_table(test_features, exclude_attrs=['_id', 'l_id', 'r_id', 'label'], strategy='mean') # Predict on the test data
predictions = best_model.predict(table=test_features, exclude_attrs=['_id', 'l_id', 'r_id', 'label'],
append=True, target_attr='predicted', inplace=False) # Evaluate the predictions
eval_result = em.eval_matches(predictions, 'label', 'predicted')
em.print_eval_summary(eval_result) # 子步骤G: 使用训练的模型匹配数据集
# 现在，我们可以使用训练的模型对两个标记进行如下匹配: candset_features = em.extract_feature_vecs(C, feature_table=F, show_progress=True)
candset_features = em.impute_table(candset_features, exclude_attrs=['_id', 'l_id', 'r_id'], strategy='mean')
predictions = best_model.predict(table=candset_features, exclude_attrs=['_id', 'l_id', 'r_id'],
append=True, target_attr='predicted', inplace=False)
matches = predictions[predictions.predicted == 1] # 请注意，匹配数据帧包含了很多存储数据集抽取功能的列。以下代码片段移除了所有非必要的列，并创建一个格式良好的拥有最终形成的整合数据集的数据帧。
from py_entitymatching.catalog import catalog_manager as cm
matches = matches[['_id', 'l_id', 'r_id', 'predicted']]
matches.reset_index(drop=True, inplace=True)
cm.set_candset_properties(matches, '_id', 'l_id', 'r_id', kaggle_data, imdb_data)
matches = em.add_output_attributes(matches, l_output_attrs=['movie_title','norm_movie_title', 'norm_title_year', 'budget',
'content_rating'],
r_output_attrs=['title','norm_title', 'norm_year', 'budget', 'mpaa'],
l_output_prefix='l_', r_output_prefix='r_',
delete_from_catalog=False)
matches.drop('predicted', axis=1, inplace=True)
matches.head()
# matches.to_csv('./data/finalResult-Magellan.csv', encoding='utf-8')
# matches.to_csv('./data/finalResult-Magellan.csv') titls = []
for col in matches.columns:
titls.append(col)
self.WriteToCsv(titls,matches.values)
# print str(datetime.datetime.now())[0:19] def match_merge_softad(self):
'''数据匹配合并'''
left_Candidate_set = ['channel_name1', 'programe_name1', 'brand_name1']
right_Candidate_set = ['channel_name2', 'programe_name2', 'brand_name2'] obj = extract_clean_data()
leftcsvfile = './data/20170708.csv'
soft_data = obj.get_date_fromCSV(leftcsvfile) dir = os.path.join(os.getcwd(), 'data\softAD-1701-1706')
flist = []
dir = unicode(dir, 'utf8')
for (dirpath, dirnames, filenames) in walk(dir):
flist.extend(filenames)
break
for fileName in flist:
if fileName.find('finalResult') == -1:
rightcsvfile = str('./data/softAD-1701-1706/') + fileName.encode('utf8')
monitor_soft_data = obj.get_date_fromCSV(rightcsvfile)
monitor_soft_data = monitor_soft_data.drop_duplicates(subset=right_Candidate_set, keep='first').copy()
monitor_soft_data.head() data_attempt1 = pd.merge(soft_data, monitor_soft_data, how='inner', left_on=left_Candidate_set,
right_on=right_Candidate_set) fp = os.path.basename(rightcsvfile)
filename = './data/softAD-1701-1706/fmerge_softad-' + fp[0:fp.rindex('.')] + '.csv'
filename = unicode(filename, 'utf8')
data_attempt1.to_csv(filename) def match_softad_Magellan(self):
obj = extract_clean_data()
logfile = os.path.join(os.getcwd(), 'log\\' + time.strftime('%Y-%m-%d') + '.txt')
log = LogFile.LogFile(logfile) # 加载串播单数据
leftcsvfile = './data/softAD-1701-1706/20170706.csv'
soft_data = obj.get_date_fromCSV(leftcsvfile)
log.WriteLog('\r\n')
log.WriteLog('加载串播单数据：%s' % os.path.basename(leftcsvfile))
print ('加载串播单数据：%s' % os.path.basename(leftcsvfile)) dir = os.path.join(os.getcwd(), 'data\softAD-1701-1706')
flist = []
dir = unicode(dir, 'utf8')
for (dirpath, dirnames, filenames) in walk(dir):
flist.extend(filenames)
break
for fileName in flist:
if fileName.find('finalResult')==-1:
fn = str('./data/softAD-1701-1706/') + fileName.encode('utf8')
self.match_softad_data(soft_data,log,leftcsvfile='./data/20170708.csv',rightcsvfile=fn) def match_softad_data(self,soft_data,log,leftcsvfile,rightcsvfile,
left_Candidate_set=['channel_name1', 'programe_name1', 'brand_name1'],
right_Candidate_set=['channel_name2', 'programe_name2', 'brand_name2'],
attr_corres_columns=[('channel_name1', 'channel_name2'),('programe_name1', 'programe_name2'),('brand_name1', 'brand_name2'),],
csvtitls=['_id', 'l_id', 'r_id', '频道名称', '整理节目全称-广告项目', '整理品牌', '频道', '节目名称', '品牌']):
'''
leftcsvfile='./data/20170708.csv'
rightcsvfile='./data/串播单-T-中央台D006-中央1套(综合)170101-170630-更新1.csv'
left_Candidate_set=['channel_name1', 'programe_name1', 'brand_name1']
right_Candidate_set=['channel_name2', 'programe_name2', 'brand_name2']
attr_corres_columns=[('channel_name1', 'channel_name2'),('programe_name1', 'programe_name2'),('brand_name1', 'brand_name2'),]
:param log: log日志
:param leftcsvfile:
:param rightcsvfile:
:param left_Candidate_set:
:param right_Candidate_set:
:param attr_corres_columns:
:return:
''' obj = extract_clean_data()
# # logfile = os.path.join(os.getcwd(), 'log\\' + time.strftime('%Y-%m-%d') + '.txt')
# # log = LogFile.LogFile(logfile)
# # 1、获取数据
# # 软广数据
# soft_data = obj.get_date_fromCSV(leftcsvfile)
# log.WriteLog('\r\n')
# log.WriteLog('加载串播单数据：%s'%os.path.basename(leftcsvfile)) log.WriteLog('\r\n')
# 软广告监测报告数据 monitor_soft_data = obj.get_date_fromCSV(rightcsvfile)
log.WriteLog('加载软广告监测报告数据：%s' % os.path.basename(rightcsvfile))
print ('加载软广告监测报告数据：%s' % os.path.basename(rightcsvfile))
# 去重复数据
# soft_data = soft_data.drop_duplicates(subset=left_Candidate_set, keep='first').copy()
# soft_data.head()
# 去重复数据
monitor_soft_data = monitor_soft_data.drop_duplicates(subset=right_Candidate_set, keep='first').copy()
monitor_soft_data.head() soft_data['id'] = range(soft_data.shape[0])
monitor_soft_data['id'] = range(monitor_soft_data.shape[0]) # 2、寻找一个候选集（拦截）
lstlen = len(left_Candidate_set)
temp = ''
for i in xrange(lstlen-1):
temp += soft_data[left_Candidate_set[i]] + ' '
soft_data['mixture'] = temp+soft_data[left_Candidate_set[lstlen - 1]] lstlen = len(right_Candidate_set)
temp = ''
for i in xrange(lstlen-1):
temp += monitor_soft_data[right_Candidate_set[i]] + ' '
monitor_soft_data['mixture'] = temp + monitor_soft_data[right_Candidate_set[lstlen - 1]] # 使用重叠系数连接两个表。
C = ssj.overlap_coefficient_join(soft_data, monitor_soft_data, 'id', 'id', 'mixture', 'mixture',
sm.WhitespaceTokenizer(),
l_out_attrs=left_Candidate_set,
r_out_attrs=right_Candidate_set,
threshold=0.65)
log.WriteLog('正在寻找一个候选集')
print ('正在寻找一个候选集')
rowCount = C.shape[0]
if rowCount <= 5:
log.WriteLog('文件%s没有匹配项' % os.path.basename(rightcsvfile))
print ('文件%s没有匹配项' % os.path.basename(rightcsvfile))
return # 3、 指定要素
em.set_key(soft_data, 'id') # specifying the key column in the kaggle dataset
em.set_key(monitor_soft_data, 'id') # specifying the key column in the imdb dataset
em.set_key(C, '_id') # specifying the key in the candidate set
em.set_ltable(C, soft_data) # specifying the left table
em.set_rtable(C, monitor_soft_data) # specifying the right table
em.set_fk_rtable(C, 'r_id') # specifying the column that matches the key in the right table
em.set_fk_ltable(C, 'l_id')
log.WriteLog('正在指定要素')
print ('正在指定要素') # 4: 拦截工具故障排除
l_list = ['l_'+ item for item in left_Candidate_set]
r_list = ['r_' + item for item in right_Candidate_set]
l_list.extend(r_list)
C[l_list].head()
# C[['l_channel_name1', 'r_channel_name2', 'l_programe_name1', 'r_programe_name2',
# 'l_brand_name1', 'r_brand_name2']].head()
log.WriteLog('正在拦截工具故障排除')
print ('正在拦截工具故障排除') # 5: 从候选集采样 # rowCount = 500
colmunCount = C.shape[1]
sampled = C.sample(rowCount, random_state=0)
# 增加label列
# 为了标记抽样的数据，我们可以在.csv文件中创建一个新的列（我们称之为label）；
# 如果配对是正确的匹配，则在此栏中填入数值1，否则，填入数值0。为避免文件重叠，让我们将新文件重命名为labeled.csv。
list = []
for item in sampled.values:
tem = float(item[colmunCount-1])
if tem > 0.6:
list.append(1)
else:
list.append(0)
sampled['label'] = list # 把采样数据保存到sampled.csv文件里面
# sampled.to_csv('./data/sampled.csv', encoding='utf-8')
sampled.to_csv('./data/labeled.csv') labeled = em.read_csv_metadata('data/labeled.csv', ltable=soft_data, rtable=monitor_soft_data,
fk_ltable='l_id', fk_rtable='r_id', key='_id')
log.WriteLog('正在从候选集采样')
print ('正在从候选集采样') # 6: 机器学习算法训练
# 现在我们可以使用抽样的数据集，针对我们的预测任务进行各种机器学习算法训练。
# 为此，我们需要将我们的数据集分割为训练和测试集，然后为我们的预测任务选择所需的机器学习方法。
log.WriteLog('正在进行机器学习算法训练')
print ('正在进行机器学习算法训练')
split = em.split_train_test(labeled, train_proportion=0.5, random_state=0)
train_data = split['train']
test_data = split['test'] dt = em.DTMatcher(name='DecisionTree', random_state=0)
svm = em.SVMMatcher(name='SVM', random_state=0)
rf = em.RFMatcher(name='RF', random_state=0)
lg = em.LogRegMatcher(name='LogReg', random_state=0)
ln = em.LinRegMatcher(name='LinReg')
nb = em.NBMatcher(name='NaiveBayes') # 在应用任何机器学习方法之前，我们需要抽取一组功能。幸运地是，一旦我们指定两个数据集中的哪些列相互对应，
# py_entitymatching程序包就可以自动抽取一组功能。指定两个数据集的列之间的对应性，
# 将启动以下代码片段。然后，它使用py_entitymatching程序包确定各列的类型。
# 通过考虑（变量l_attr_types和r_attr_types中存储的）各个数据集中列的类型，
# 并使用软件包推荐的编译器和类似功能，我们可以抽取一组用于抽取功能的说明。
# 请注意，变量F并非所抽取功能的集合，相反，它会对说明编码以处理功能。
attr_corres = em.get_attr_corres(soft_data, monitor_soft_data)
attr_corres['corres'] = attr_corres_columns l_attr_types = em.get_attr_types(soft_data)
r_attr_types = em.get_attr_types(monitor_soft_data) tok = em.get_tokenizers_for_matching()
sim = em.get_sim_funs_for_matching() F = em.get_features(soft_data, monitor_soft_data, l_attr_types, r_attr_types, attr_corres, tok, sim) # 考虑所需功能的集合F，现在我们可以计算训练数据的功能值，并找出我们数据中丢失数值的原因。
# 在这种情况下，我们选择将丢失值替换为列的平均值。 train_features = em.extract_feature_vecs(train_data, feature_table=F, attrs_after='label', show_progress=False)
train_features = em.impute_table(train_features, exclude_attrs=['_id', 'l_id', 'r_id', 'label'],
strategy='mean') # 使用计算的功能，我们可以评估不同机器学习算法的性能，并为我们的匹配任务选择最佳的算法 # result = em.select_matcher([ln, lg, svm, nb, rf, dt], table=train_features,
# exclude_attrs=['_id', 'l_id', 'r_id', 'label'], k=5,
# target_attr='label', metric='f1', random_state=0)
result = em.select_matcher([ln, nb, rf, dt], table=train_features,
exclude_attrs=['_id', 'l_id', 'r_id', 'label'], k=5,
target_attr='label', metric='f1', random_state=0)
print result['cv_stats'] # 7: 评估我们的匹配质量
log.WriteLog('正在进行评估匹配质量')
print ('正在进行评估匹配质量')
best_model = result['selected_matcher'] best_model.fit(table=train_features, exclude_attrs=['_id', 'l_id', 'r_id', 'label'], target_attr='label') test_features = em.extract_feature_vecs(test_data, feature_table=F, attrs_after='label', show_progress=False)
test_features = em.impute_table(test_features, exclude_attrs=['_id', 'l_id', 'r_id', 'label'], strategy='mean') # Predict on the test data
predictions = best_model.predict(table=test_features, exclude_attrs=['_id', 'l_id', 'r_id', 'label'],
append=True, target_attr='predicted', inplace=False) # Evaluate the predictions
eval_result = em.eval_matches(predictions, 'label', 'predicted')
em.print_eval_summary(eval_result) # 8: 使用训练的模型匹配数据集
# 现在，我们可以使用训练的模型对两个标记进行如下匹配:
log.WriteLog('正在进行用训练的模型匹配数据集')
print ('正在进行用训练的模型匹配数据集')
candset_features = em.extract_feature_vecs(C, feature_table=F, show_progress=True)
candset_features = em.impute_table(candset_features, exclude_attrs=['_id', 'l_id', 'r_id'], strategy='mean')
predictions = best_model.predict(table=candset_features, exclude_attrs=['_id', 'l_id', 'r_id'],
append=True, target_attr='predicted', inplace=False)
matches = predictions[predictions.predicted == 1] # 请注意，匹配数据帧包含了很多存储数据集抽取功能的列。以下代码片段移除了所有非必要的列，并创建一个格式良好的拥有最终形成的整合数据集的数据帧。
from py_entitymatching.catalog import catalog_manager as cm
matches = matches[['_id', 'l_id', 'r_id', 'predicted']]
matches.reset_index(drop=True, inplace=True)
cm.set_candset_properties(matches, '_id', 'l_id', 'r_id', soft_data, monitor_soft_data)
matches = em.add_output_attributes(matches,
l_output_attrs=left_Candidate_set,
r_output_attrs=right_Candidate_set,
l_output_prefix='l_', r_output_prefix='r_',
delete_from_catalog=False)
matches.drop('predicted', axis=1, inplace=True)
matches.head()
# matches.to_csv('./data/finalResult-Magellan.csv', encoding='utf-8')
# matches.to_csv('./data/finalResult-Magellan.csv') # titls = []
# for col in matches.columns:
# titls.append(col)
csvtitls=['_id','l_id','r_id','频道名称','整理节目全称-广告项目','整理品牌','频道','节目名称','品牌']
log.WriteLog('把匹配的最终数据导出到csv文件')
print ('把匹配的最终数据导出到csv文件')
fp = os.path.basename(rightcsvfile)
filename = './data/softAD-1701-1706/finalResult-'+fp[0:fp.rindex('.')] + '.csv'
filename = unicode(filename,'utf8')
self.WriteToCsv(csvtitls, matches.values,filename) return #obj = match_merge_data()
# obj.match_merge_Kaggle_IMDB()
# obj.match_merge_Kaggle_IMDB_stringsimjoin()
# obj.match_merge_Kaggle_IMDB_Magellan()
#obj.match_softad_Magellan()
# obj.match_merge_softad() ########################################################################################## #coding=utf8
#数据匹配和合并 import os
import datetime
import time
import re
import csv
import pandas as pd
from os import walk
import urllib
import py_stringsimjoin as ssj
import py_stringmatching as sm from pandas.core.frame import DataFrame
from extract_clean import extract_clean_data
import py_entitymatching as em
import LogFile class match_merge_data:
def __init__(self):
pass def WriteToCsv(self, titls, data,filename='./data/finalResult-Magellan.csv'): # csvfile = os.path.join(os.getcwd(), 'csvtest.csv')
with open(filename, 'wb') as f:
writer = csv.writer(f)
# 标题
writer.writerow(titls)
for item in data:
# 内容
writer.writerow(item) def match_merge_list(self):
'''数据匹配合并'''
obj = extract_clean_data()
genreslist = obj.extract_genreslist()
ratinglist = obj.extract_ratinglist()
print ratinglist.shape[0]
print genreslist.shape[0]
brief_imdb_data = pd.merge(ratinglist, genreslist, how='inner', on=['norm_movie', 'year'])
brief_imdb_data.head()
print brief_imdb_data.shape[0] def match_merge_Kaggle_IMDB(self):
'''数据匹配合并'''
obj = extract_clean_data()
kaggle_data = obj.extract_kaggle_dataset()
imdb_data = obj.extract_imdb_dataset()
# print kaggle_data.shape[0] #4919
# print imdb_data.shape[0] #869178
# 方法1
data_attempt1 = pd.merge(imdb_data, kaggle_data, how='inner', left_on=['norm_title', 'norm_year'],
right_on=['norm_movie_title', 'norm_title_year'])
# print data_attempt1.shape[0] #4261
data_attempt1.to_csv('./data/finalResult-IMDB.csv') def match_merge_Kaggle_IMDB_stringsimjoin(self):
'''数据匹配合并'''
obj = extract_clean_data()
kaggle_data = obj.extract_kaggle_dataset()
imdb_data = obj.extract_imdb_dataset() # 方法2
imdb_data['id'] = range(imdb_data.shape[0])
kaggle_data['id'] = range(kaggle_data.shape[0])
#使用编辑距离度量来连接两个表。从左表和右表找到元组，使编辑连接属性之间的距离满足输入条件阈
#。 例如，如果比较运算符是'<='，则找到元组对，其编码距离是字符串之间的值连接属性小于或等于输入阈值，as在“阈值”中指定。
similar_titles = ssj.edit_distance_join(imdb_data, kaggle_data, 'id', 'id', 'norm_title',
'norm_movie_title', l_out_attrs=['title','norm_title', 'norm_year'],
r_out_attrs=['movie_title','norm_movie_title', 'norm_title_year'], threshold=1)
# selecting the entries that have the same production year
data_attempt2 = similar_titles[similar_titles.r_norm_title_year == similar_titles.l_norm_year]
data_attempt2.to_csv('./data/finalResult-stringsimjoin.csv')
# data_attempt2.to_csv('./data/finalResult-stringsimjoin.csv', encoding='utf-8')
# print data_attempt2.shape[0]#4696
# print data_attempt3.shape[0] # 10525 def match_merge_Kaggle_IMDB_Magellan(self):
# print str(datetime.datetime.now())[0:19]
'''数据匹配合并'''
obj = extract_clean_data()
kaggle_data = obj.extract_kaggle_dataset()
imdb_data = obj.extract_imdb_dataset() imdb_data['id'] = range(imdb_data.shape[0])
kaggle_data['id'] = range(kaggle_data.shape[0]) # 方法3
# 子步骤A: 寻找一个候选集（拦截）
# repeating the same thing for the Kaggle dataset
ssj.dataframe_column_to_str(kaggle_data, 'budget', inplace=True)
kaggle_data['mixture'] = kaggle_data['norm_movie_title'] + ' ' + kaggle_data['norm_title_year'] + kaggle_data['budget'] # transforming the "budget" column into string and creating a new **mixture** column
ssj.dataframe_column_to_str(imdb_data, 'budget', inplace=True)
imdb_data['mixture'] = imdb_data['norm_title'] + ' ' + imdb_data['norm_year'] + ' ' + imdb_data['budget'] #使用重叠系数连接两个表。
C = ssj.overlap_coefficient_join(kaggle_data, imdb_data, 'id', 'id', 'mixture', 'mixture',
sm.WhitespaceTokenizer(),
l_out_attrs=['movie_title','norm_movie_title', 'norm_title_year', 'duration',
'budget', 'content_rating'],
r_out_attrs=['title','norm_title', 'norm_year', 'length', 'budget', 'mpaa'],
threshold=0.65)
# C.shape()
rowCount = C.shape[0] #
# print C.shape[0] # 子步骤B: 指定要素
em.set_key(kaggle_data, 'id') # specifying the key column in the kaggle dataset
em.set_key(imdb_data, 'id') # specifying the key column in the imdb dataset
em.set_key(C, '_id') # specifying the key in the candidate set
em.set_ltable(C, kaggle_data) # specifying the left table
em.set_rtable(C, imdb_data) # specifying the right table
em.set_fk_rtable(C, 'r_id') # specifying the column that matches the key in the right table
em.set_fk_ltable(C, 'l_id') # 子步骤C: 拦截工具故障排除
C[['l_norm_movie_title', 'r_norm_title', 'l_norm_title_year', 'r_norm_year',
'l_budget', 'r_budget', 'l_content_rating', 'r_mpaa']].head() # 子步骤D: 从候选集采样,label列
# samplelen = rowCount
sampled = C.sample(rowCount, random_state=0) #增加label列
# 为了标记抽样的数据，我们可以在.csv文件中创建一个新的列（我们称之为label）；
# 如果配对是正确的匹配，则在此栏中填入数值1，否则，填入数值0。为避免文件重叠，让我们将新文件重命名为labeled.csv。
list =[]
for index in xrange(len(sampled.values)): tem =float(sampled.values[index][13])
if tem>0.6:
list.append(1)
else:
list.append(0)
sampled['label'] =list #把采样数据保存到sampled.csv文件里面
# sampled.to_csv('./data/sampled.csv', encoding='utf-8')
sampled.to_csv('./data/sampled.csv') # If you would like to avoid labeling the pairs for now, you can download the labled.csv file from
# BigGorilla using the following command (if you prefer to do it yourself, command the next line)
# response = urllib.urlretrieve('https://anaconda.org/BigGorilla/datasets/1/download/labeled.csv',
# './data/labeled.csv')
labeled = em.read_csv_metadata('data/labeled.csv', ltable=kaggle_data, rtable=imdb_data,
fk_ltable='l_id', fk_rtable='r_id', key='_id')
# tt = labeled.head() # 子步骤E: 机器学习算法训练
# 现在我们可以使用抽样的数据集，针对我们的预测任务进行各种机器学习算法训练。
# 为此，我们需要将我们的数据集分割为训练和测试集，然后为我们的预测任务选择所需的机器学习方法。
split = em.split_train_test(labeled, train_proportion=0.5, random_state=0)
train_data = split['train']
test_data = split['test'] dt = em.DTMatcher(name='DecisionTree', random_state=0)
svm = em.SVMMatcher(name='SVM', random_state=0)
rf = em.RFMatcher(name='RF', random_state=0)
lg = em.LogRegMatcher(name='LogReg', random_state=0)
ln = em.LinRegMatcher(name='LinReg')
nb = em.NBMatcher(name='NaiveBayes') # 在应用任何机器学习方法之前，我们需要抽取一组功能。幸运地是，一旦我们指定两个数据集中的哪些列相互对应，
# py_entitymatching程序包就可以自动抽取一组功能。指定两个数据集的列之间的对应性，
# 将启动以下代码片段。然后，它使用py_entitymatching程序包确定各列的类型。
# 通过考虑（变量l_attr_types和r_attr_types中存储的）各个数据集中列的类型，
# 并使用软件包推荐的编译器和类似功能，我们可以抽取一组用于抽取功能的说明。
# 请注意，变量F并非所抽取功能的集合，相反，它会对说明编码以处理功能。
attr_corres = em.get_attr_corres(kaggle_data, imdb_data)
attr_corres['corres'] = [('norm_movie_title', 'norm_title'),
('norm_title_year', 'norm_year'),
('content_rating', 'mpaa'),
('budget', 'budget'),
] l_attr_types = em.get_attr_types(kaggle_data)
r_attr_types = em.get_attr_types(imdb_data) tok = em.get_tokenizers_for_matching()
sim = em.get_sim_funs_for_matching() F = em.get_features(kaggle_data, imdb_data, l_attr_types, r_attr_types, attr_corres, tok, sim) # 考虑所需功能的集合F，现在我们可以计算训练数据的功能值，并找出我们数据中丢失数值的原因。
# 在这种情况下，我们选择将丢失值替换为列的平均值。 train_features = em.extract_feature_vecs(train_data, feature_table=F, attrs_after='label', show_progress=False)
train_features = em.impute_table(train_features, exclude_attrs=['_id', 'l_id', 'r_id', 'label'],
strategy='mean') # 使用计算的功能，我们可以评估不同机器学习算法的性能，并为我们的匹配任务选择最佳的算法 result = em.select_matcher([ ln, lg,svm,nb,rf, dt], table=train_features,
exclude_attrs=['_id', 'l_id', 'r_id', 'label'], k=5,
target_attr='label', metric='f1', random_state=0)
print result['cv_stats'] # 子步骤F: 评估我们的匹配质量 best_model = result['selected_matcher'] best_model.fit(table=train_features, exclude_attrs=['_id', 'l_id', 'r_id', 'label'], target_attr='label') test_features = em.extract_feature_vecs(test_data, feature_table=F, attrs_after='label', show_progress=False)
test_features = em.impute_table(test_features, exclude_attrs=['_id', 'l_id', 'r_id', 'label'], strategy='mean') # Predict on the test data
predictions = best_model.predict(table=test_features, exclude_attrs=['_id', 'l_id', 'r_id', 'label'],
append=True, target_attr='predicted', inplace=False) # Evaluate the predictions
eval_result = em.eval_matches(predictions, 'label', 'predicted')
em.print_eval_summary(eval_result) # 子步骤G: 使用训练的模型匹配数据集
# 现在，我们可以使用训练的模型对两个标记进行如下匹配: candset_features = em.extract_feature_vecs(C, feature_table=F, show_progress=True)
candset_features = em.impute_table(candset_features, exclude_attrs=['_id', 'l_id', 'r_id'], strategy='mean')
predictions = best_model.predict(table=candset_features, exclude_attrs=['_id', 'l_id', 'r_id'],
append=True, target_attr='predicted', inplace=False)
matches = predictions[predictions.predicted == 1] # 请注意，匹配数据帧包含了很多存储数据集抽取功能的列。以下代码片段移除了所有非必要的列，并创建一个格式良好的拥有最终形成的整合数据集的数据帧。
from py_entitymatching.catalog import catalog_manager as cm
matches = matches[['_id', 'l_id', 'r_id', 'predicted']]
matches.reset_index(drop=True, inplace=True)
cm.set_candset_properties(matches, '_id', 'l_id', 'r_id', kaggle_data, imdb_data)
matches = em.add_output_attributes(matches, l_output_attrs=['movie_title','norm_movie_title', 'norm_title_year', 'budget',
'content_rating'],
r_output_attrs=['title','norm_title', 'norm_year', 'budget', 'mpaa'],
l_output_prefix='l_', r_output_prefix='r_',
delete_from_catalog=False)
matches.drop('predicted', axis=1, inplace=True)
matches.head()
# matches.to_csv('./data/finalResult-Magellan.csv', encoding='utf-8')
# matches.to_csv('./data/finalResult-Magellan.csv') titls = []
for col in matches.columns:
titls.append(col)
self.WriteToCsv(titls,matches.values)
Python数据整合与数据准备-BigGorilla实例应用的更多相关文章
- Python数据整合与数据准备-BigGorilla介绍
参考文档:http://www.biggorilla.org/zh-hans/walkt/ 一.前言 “根据访谈记录和专家估计,数据科学家将50%至80%的时间花在搜集和准备难以梳理的数字数据的琐碎工 ...
- Python数据整合与数据准备-BigGorilla应用
一.前言 要应用BigGorilla框架对应数据进行数据的处理与匹配,那么首先要下载Anaconda安装,下载地址:https://www.continuum.io/downloads Anacond ...
- 用python实现简单EXCEL数据统计的实例
用python实现简单EXCEL数据统计的实例 下面小编就为大家带来一篇用python实现简单EXCEL数据统计的实例.小编觉得挺不错的,现在就分享给大家,也给大家做个参考.一起跟随小编过来看看吧 任 ...
- PYTHON爬虫实战_垃圾佬闲鱼爬虫转转爬虫数据整合自用二手急速响应捡垃圾平台_3(附源码持续更新)
说明 文章首发于HURUWO的博客小站,本平台做同步备份发布. 如有浏览或访问异常图片加载失败或者相关疑问可前往原博客下评论浏览. 原文链接 PYTHON爬虫实战_垃圾佬闲鱼爬虫转转爬虫数据整合自用二 ...
- Python数学建模-02.数据导入
数据导入是所有数模编程的第一步,比你想象的更重要. 先要学会一种未必最佳,但是通用.安全.简单.好学的方法. 『Python 数学建模 @ Youcans』带你从数模小白成为国赛达人. 1. 数据导入 ...
- JavaScript 解析 Django Python 生成的 datetime 数据 时区问题解决
JavaScript 解析 Django/Python 生成的 datetime 数据 当Web后台使用Django时,后台生成的时间数据类型就是Python类型的. 项目需要将几个时间存储到数据库中 ...
- 用IBM WebSphere DataStage进行数据整合: 第 1 部分
转自:http://www.ibm.com/developerworks/cn/data/library/techarticles/dm-0602zhoudp/ 引言 传统的数据整合方式需要大量的手工 ...
- Python 进程之间共享数据
最近遇到多进程共享数据的问题,到网上查了有几篇博客写的蛮好的,记录下来方便以后查看. 一.Python multiprocessing 跨进程对象共享 在mp库当中,跨进程对象共享有三种方式,第一种 ...
- python 数据可视化 -- 读取数据
从 CSV 文件中读取数据(CSV) import sys import csv # python 内置该模块 支持各种CSV文件 file_name = r"..\ch02_data\ch ...
随机推荐
- cygwin与vim配置
参考 http://www.jeepshoe.org/810958442.htm cygwin安装包管理器 通过终端安装apt-cyg之前选要安装以下软件包wget tar gawk bzip2 ap ...
- php使用curl模拟登录带验证码的网站
需求是这样的,需要登录带验证码的网站,获取数据,但是不可能人为一直去记录数据,想通过自动采集的方式进行,如下是试验出来的结果代码!有需要的可以参考下! <?php namespace Home\ ...
- js中给easyui的一列添加按钮
$("#totalTb").datagrid({ columns: [[ { field: 'ENTITY_ACTNAME', title: '活动名 ...
- 【反演复习计划】【bzoj2154】Crash的数字表格
膜拜cdc……他的推导详细到我这种蒟蒻都能看得懂! 膜拜的传送门 所以我附一下代码就好了. #include<bits/stdc++.h> #define N 10000005 #defi ...
- 用js和jQuery做轮播图
Javascript或jQuery做轮播图 css样式 <style> a{ text-decoration:none; } .naver{ width: 100%; position:r ...
- mysql内连接、左连接、右连接举例说明
如下: CREATE TABLE tb ( id INT PRIMARY KEY, NAME VARCHAR (20) ) ; CREATE TABLE ta ( id INT PRIMARY KEY ...
- [ python3 ] 基于zabbix 自动抓取每天监控数据
通过python登录到zabbix直接抓取每天的数据的图片趋势图,并制作成静态index.html给与展示并发送提示邮件. 操作系统:Centos6.7 python版本:python3.5 #!/u ...
- 【 Zabbix 】 — 基础安装
一.基础环境 (1)centos6.7 x64 (2)JDK1.8 and zabbix-2.4.8(JDK是为了后期可以监控tomcat) (3)虚拟机测试环境 二.安装LAMP环境 这里为了快速搭 ...
- css的class， id等常用命名规则
CSS的class.id.css文件名的常用命名规则 (一)常用的CSS命名规则 头:header 内容:content/container 尾:footer 导航:nav 侧栏:sid ...
- jQuery中操作事件
JavaScript中操作事件的方式是这样的: 元素.on事件名=function(){ //事件执行的代码 } 但是jQuery有点不同,他的格式是这样的: 元素.on("事件名" ...