在PySpark中将Python Dict转换为稀疏RDD或DF

Question

我有一些我在Pandas中原型化的代码，我正在尝试转换为PySpark代码。它使用urlparse Python库将通用URI解析为Python dict，将键转换为新列，然后将这些新列与原始数据连接起来。下面是一个简化的例子。在真实数据集中有38列，我关心保留所有这些列。

# create some sample data
df_ex = pd.DataFrame([[102,'text1',u'/some/website/page.json?ovpevu&colc=1452802104103&si=569800363b029b74&rev=v4.1.2-wp&jsl=161&ln=en&pc=men&dp=www.mysite.com&qfq=news/this-is-an-article&of=2&uf=1&pd=0&irt=0&md=0&ct=1&tct=0&abt=0&lt=792&cdn=1&lnlc=gb&tl=c=141,m=433,i=476,xm=1243,xp=1254&pi=2&&rb=0&gen=100&callback=_ate.track.hsr&mk=some,key,words,about,the,article&'],
          [781,'text2',u'/libtrc/hearst-network/loader.js'],
          [9001,'text3',u'/image/view/-/36996720/highRes/2/-/maxh/150/maxw/150/mypic.jpg'],
          [121,'text4',u'/website/page2.json?ovpevu&colc=1452802104103&si=569800363b029b74&rev=v4.1.2-wp&qqd=1&pd=0&irt=0&md=0&zzct=1&tct=0&abt=0&lt=792&cdn=0&lnlc=gb&tl=c=414,m=32,i=41,xm=1000,xp=111&callback=_ate.track.hsr&mk=some,other,key,words,about,the,article&'],
          [781,'text5',u'/libtrc/hearst-network/loader.js']],columns=['num','text','uri'])

# parse the URI to a dict using urlparse
df_ex['uri_dict'] = df_ex['uri'].apply(lambda x: dict(urlparse.parse_qsl(urlparse.urlsplit(x).query)))

# convert the parsed dict to a series
df_ex_uridict_series = df_ex['uri_dict'].apply(pd.Series)

# concatenate the parsed dict (now columns) back with original DF
df_final = pd.concat([df_ex, df_ex_uridict_series], axis=1).drop('uri_dict', axis=1)

导致看起来像这样的东西（裁剪）：

结果非常稀少，但那没关系。对于应用程序，我实际上更喜欢它是一种稀疏矩阵（虽然我可以确信是否有一个很好的替代方案，密集的方法）。而这正是我试图在PySpark中重新创建的结果。

到目前为止我已经（在PySpark 2.1.0中）这个（使用相同的数据）。

# urlparse library
import urlparse

# create the sample data as RDD
data = sc.parallelize([[102,'text1',u'/some/website/page.json?ovpevu&colc=1452802104103&si=569800363b029b74&rev=v4.1.2-wp&jsl=161&ln=en&pc=men&dp=www.mysite.com&qfq=news/this-is-an-article&of=2&uf=1&pd=0&irt=0&md=0&ct=1&tct=0&abt=0&lt=792&cdn=1&lnlc=gb&tl=c=141,m=433,i=476,xm=1243,xp=1254&pi=2&&rb=0&gen=100&callback=_ate.track.hsr&mk=some,key,words,about,the,article&'],[781,'text2',u'/libtrc/hearst-network/loader.js'],[9001,'text3',u'/image/view/-/36996720/highRes/2/-/maxh/150/maxw/150/mypic.jpg'],[121,'text4',u'/website/page2.json?ovpevu&colc=1452802104103&si=569800363b029b74&rev=v4.1.2-wp&qqd=1&pd=0&irt=0&md=0&zzct=1&tct=0&abt=0&lt=792&cdn=0&lnlc=gb&tl=c=414,m=32,i=41,xm=1000,xp=111&callback=_ate.track.hsr&mk=some,other,key,words,about,the,article&'],[781,'text5',u'/libtrc/hearst-network/loader.js']])

# simple map to parse the uri
uri_parsed = data.map(list).map(lambda x: [x[0],x[1],urlparse.parse_qs(urlparse.urlsplit(x[2]).query)])

这让我非常接近，一个python dict嵌套在RDD的每个“行”中。像这样：

In [187]: uri_parsed.take(3)
Out[187]:
[[102,
  'text1',
  {u'abt': [u'0'],
   u'callback': [u'_ate.track.hsr'],
   u'cdn': [u'1'],
   u'colc': [u'1452802104103'],
   u'ct': [u'1'],
   u'dp': [u'www.mysite.com'],
   u'gen': [u'100'],
   u'irt': [u'0'],
   u'jsl': [u'161'],
   u'ln': [u'en'],
   u'lnlc': [u'gb'],
   u'lt': [u'792'],
   u'md': [u'0'],
   u'mk': [u'some,key,words,about,the,article'],
   u'of': [u'2'],
   u'pc': [u'men'],
   u'pd': [u'0'],
   u'pi': [u'2'],
   u'qfq': [u'news/this-is-an-article'],
   u'rb': [u'0'],
   u'rev': [u'v4.1.2-wp'],
   u'si': [u'569800363b029b74'],
   u'tct': [u'0'],
   u'tl': [u'c=141,m=433,i=476,xm=1243,xp=1254'],
   u'uf': [u'1']}],
 [781, 'text2', {}],
 [9001, 'text3', {}]]

值包含列表，但没关系。他们可以保持列表。

此时我想做的是解析dict中的键/值对（如在Pandas中），从键创建新列，然后放置值（或值列表，在这种情况下） ）在RDD。

我尝试过的一些事情：

• 走向成熟的PySpark DF：写了一个UDF并使用with_column应用在DF中创建一个新列。这有效，但它给了我整个字典作为单个字符串（没有键和值在引号中）。我没有试图推进这个并添加引号（想象有更好的方法）。
• 拆分原始DF：首先使用monotonically_increasing_id()为每个DF行分配一个唯一ID，拆分两列（新ID和URI），将拆分转换为RDD，然后解析。这将让我然后加入（使用ID），但它没有帮助创建我想要的“稀疏矩阵”。

我还想到，这些技术（使用带有Hive数据存储的Spark v2.1.0）可能不是表示此类数据的正确基础技术。也许无架构的数据存储会更好。但是，我现在被限制使用Spark和Hive作为数据存储区。

任何帮助将不胜感激！

Answer 1

我最近在研究一个类似的问题，解析包含由＆＃39; =＆＃39;分隔的键值对的字符串，其中可能的键事先未知。

我不确定它是最有效的解决方案，但我想出了一个解决方案，它会在rdd中运行几次，以发现和处理任意标记。

首先，解析标记行的URL和num-text对：

def urlparsefn(url):
    return urlparse.parse_qs(urlparse.urlsplit(url).query)

# parse the uri to a dictionary
uri_parsed = data.map(lambda x: (x[0],x[1],urlparsefn(x[2])))

然后，您可以通过提取每个uri字典的唯一键来提取所有不同的标记，然后使用Python set将它们聚合在一起，这样您就可以轻松删除重复项。

# We need to discover all the unique keys before we will know which columns our data frame will have
combOp = (lambda x, y: x.union(y))
possible_keys_set = uri_parsed.map(lambda x: set(x[2].keys())).aggregate(set(), combOp, combOp)
possible_keys = sorted(list(possible_keys_set)) # sets have no order, this will give us alphabetical order in the final dataframe

现在我们拥有了所有唯一可能的密钥，我们可以提取标记该行的不同num和text，然后确保每个字典中都包含所有标记，并使用一些占位符文本来标记该元素。 t存在于特定的uri字典中。然后，您可以使用Python中的关键字参数构建一个Rdd行。

def attrmap(urirow, possible_keys):
    # Extract the 3 parts of the uri tuple
    num = urirow[0]
    text = urirow[1]
    uridict = urirow[2]

    # Assign the known fields identifying the row
    uridict['num'] = num
    uridict['text'] = text

    # Run through the possible keys, add a placeholder for any keys not present in the row
    for key in possible_keys:
        if key not in uridict:
            uridict[key] = 'N/A' # Some place holder for values in the list of possible keys, but not in the current uri dictionary
        else:
            uridict[key] = uridict[key][0] # All the lists only have 1 item, so just extract the item

    return uridict

# Create an rdd of Row type, using the dictionary as kwargs
uri_allkeys = uri_parsed.map(lambda x: Row(**attrmap(x, possible_keys)))

然后，最后一件事是根据num，text和所有提取的可能列构建新数据帧的模式。

# Create an item in the schema for the known fields, and each possible key
df_schema = StructType()
for possible_key in ['num','text']+possible_keys:
    df_schema.add(possible_key, StringType(), True)

# Use the new schema and rdd of rows to create the dataframe
uri_parsed_df = spark.createDataFrame(uri_allkeys, df_schema)

这应该为数据帧提供任意列。希望这有帮助！