지능형 추천 시스템을
만들다

MATCH (c:Customer)-[sr:SUMMER_2019]->()
WHERE sr.embedding is not null
RETURN gds.graph.project(
  'myGraph',
  c,
  null,
  {
    sourceNodeProperties: sr { .embedding },
    targetNodeProperties: {}
  }
)

CALL gds.knn.write('myGraph', {
    writeRelationshipType: 'SUMMER_2019_SIMILAR',
    writeProperty: 'score',
    topK: 5,
    nodeProperties: ['embedding'],
    similarityCutoff: 0.9
})
YIELD nodesCompared, relationshipsWritten

CALL gds.graph.drop('myGraph')

MATCH (source:Customer)-[r:SUMMER_2019_SIMILAR]->(target)
RETURN gds.graph.project(
  'communityGraph',
  source,
  target,
  {
    relationshipProperties: r { .score }
  },
  { undirectedRelationshipTypes: ['*'] }
)

CALL gds.louvain.write('communityGraph', { writeProperty: 'summer_2019_community' })
YIELD communityCount, modularity, modularities

MATCH (c:Customer) WHERE c.summer_2019_community IS NOT NULL
RETURN c.summer_2019_community, COUNT(c) as count
ORDER BY count DESC

MATCH (c:Customer)-[r:SUMMER_2019]->()
WHERE c.summer_2019_community=133
WITH split(r.summary, '\n') AS s
WITH CASE WHEN s[2] <> '' THEN s[2] ELSE s[3] END AS d
return d LIMIT 5

MATCH (c:Customer)
WHERE c.summer_2019_community=133
WITH c LIMIT 10
MATCH (c)-[:SUMMER_2019]->(start)
MATCH (c)-[:FALL_2019]->(end)
WITH c, start, end
CALL {
    WITH start, end
    MATCH p=(start)-[:NEXT*]->(end)
    WITH nodes(p) as nodes
    UNWIND nodes as n
    MATCH (n)-[:HAS_ARTICLE]->(a)
    WITH a LIMIT 3
    RETURN collect(a.desc) as articles
}
WITH c, articles
RETURN articles

MATCH (c:Customer) where c.summer_2019_community is not null
WITH  c.summer_2019_community as community, toInteger(c.age) as age,  c
WITH community,
    CASE WHEN age < 10 THEN "Young"
         WHEN 10 < age < 20 THEN "Teen"
         WHEN 20 < age < 30 THEN "Youth"
         WHEN 30 < age < 50 THEN "Adult"
         ELSE "Old"
    END as ageGroup,
    c
WITH community, ageGroup, count(*) as count
CALL {
    WITH community
    MATCH (c:Customer) where c.summer_2019_community=community
    RETURN count(*) as totalCommunity
}
WITH community, ageGroup, count, totalCommunity
WITH community, ageGroup, round(count*100.0/totalCommunity, 2) as ratio
WITH community, collect({ageGroup: ageGroup, ratio:ratio}) as data
CALL {
    WITH community, data
    UNWIND data as d
    WITH community, d
    ORDER BY d.ratio DESC
    RETURN community as c, d.ageGroup as a, d.ratio as r
    LIMIT 1
}
RETURN c as community, a as ageGroup, r as ratio
ORDER BY r DESC

MATCH (c:Customer)-[r:SUMMER_2019]->()
WHERE c.summer_2019_community=5823
WITH c, split(r.summary, '\n') AS s
WITH c, CASE WHEN s[2] <> '' THEN s[2] ELSE s[3] END AS d
RETURN d LIMIT 5

MATCH (c:Customer)-[r:SUMMER_2019]->()
WHERE c.id='000ae8a03447710b4de81d85698dfc0559258c93136650efc2429fcca80d699a'
WITH c, split(r.summary, '\n') AS s
WITH c, CASE WHEN s[2] <> '' THEN s[2] ELSE s[3] END AS d
RETURN d

MATCH (c:Customer {id:'000ae8a03447710b4de81d85698dfc0559258c93136650efc2429fcca80d699a'})
WITH c
CALL {
    -- 이 고객이 구매한 품목들을 얻는다
    WITH c
    MATCH (c)-[:SUMMER_2019]->(start)
    MATCH (c)-[:FALL_2019]->(end)
    MATCH p=(start)-[:NEXT*]->(end)
    WITH nodes(p) as txns
    UNWIND txns as txn
    MATCH (txn)-[:HAS_ARTICLE]->(a)
    WITH DISTINCT a
    RETURN collect(a) as articles
}
WITH c, articles, c.summer_2019_community as community

CALL {
    WITH community
    MATCH (inc:Customer) WHERE inc.summer_2019_community = community
    MATCH (inc)-[:SUMMER_2019]->(start)
    MATCH (inc)-[:FALL_2019]->(end)
    MATCH p=(start)-[:NEXT*]->(end)
    WITH nodes(p) as txns
    UNWIND txns as txn
    MATCH (txn)-[:HAS_ARTICLE]->(a)
    WITH DISTINCT a
    RETURN collect(a) as inCommunityArticles
}
WITH c, articles, community, inCommunityArticles

CALL {
    WITH community
    MATCH (outc:Customer) WHERE outc.summer_2019_community is not null
        and outc.summer_2019_community <> community
    MATCH (outc)-[:SUMMER_2019]->(start)
    MATCH (outc)-[:FALL_2019]->(end)
    MATCH p=(start)-[:NEXT*]->(end)
    WITH nodes(p) as txns
    UNWIND txns as txn
    MATCH (txn)-[:HAS_ARTICLE]->(a)
    WITH DISTINCT a
    RETURN collect(a) as outCommunityArticles
}
WITH c, articles, community, inCommunityArticles, outCommunityArticles

-- 원 고객이 속한 커뮤니티 밖 고객들이 구매한 품목을 제거한다
WITH c, articles, apoc.coll.subtract(inCommunityArticles, outCommunityArticles) as onlyInCommunity
-- onlyInCommunity에서 원 고객이 구매한 품목을 제거한다
WITH c, apoc.coll.subtract(onlyInCommunity, articles) as notPurchasedButInCommunity
-- 남은 목록에서 10개의 추천 품목을 제공한다. 단순화와 시연을 위해 10개로
-- 제한한다. 모든 품목을 보고 다른 측면으로 그룹화해 다른 추천을 제공할 수도 있다
UNWIND notPurchasedButInCommunity as article
RETURN article.id as id, article.desc as desc
LIMIT 10

MATCH (c:Customer) where c.id='00281c683a8eb0942e22d88275ad756309895813e0648d4b97c7bc8178502b33'
WITH c
CALL {
    WITH c
    MATCH (c)-[:SUMMER_2019]->(start)
    MATCH (c)-[:FALL_2019]->(end)
    MATCH p=(start)-[:NEXT*]->(end)
    WITH nodes(p) as txns
    UNWIND txns as txn
    MATCH (txn)-[:HAS_ARTICLE]->(a)-[:HAS_SECTION]->(s)
    WITH DISTINCT a,s
    RETURN collect({section:s.name, article:a.desc}) as articles
}
return articles

MATCH (c:Customer {id:'00281c683a8eb0942e22d88275ad756309895813e0648d4b97c7bc8178502b33'})
MATCH (s:Section) WHERE s.name='Kids Boy'
WITH c,s
CALL {
    -- 관심 섹션에 속한, 이 고객이 구매한 품목들을 얻는다
    WITH c,s
    MATCH (c)-[:SUMMER_2019]->(start)
    MATCH (c)-[:FALL_2019]->(end)
    MATCH p=(start)-[:NEXT*]->(end)
    WITH nodes(p) as txns
    UNWIND txns as txn
    MATCH (txn)-[:HAS_ARTICLE]->(a)-[:HAS_SECTION]->(s)
    WITH DISTINCT a
    RETURN collect(a) as articles
}
WITH c, articles,s, c.summer_2019_community as community

CALL {
    WITH community, s
    MATCH (inc:Customer) WHERE inc.summer_2019_community = community
    MATCH (inc)-[:SUMMER_2019]->(start)
    MATCH (inc)-[:FALL_2019]->(end)
    MATCH p=(start)-[:NEXT*]->(end)
    WITH nodes(p) as txns, s
    UNWIND txns as txn
    MATCH (txn)-[:HAS_ARTICLE]->(a)-[:HAS_SECTION]->(s)
    WITH DISTINCT a
    RETURN collect(a) as inCommunityArticles
}
WITH c, articles, community, inCommunityArticles, s

CALL {
    WITH community, s
    MATCH (outc:Customer) WHERE outc.summer_2019_community is not null
        and outc.summer_2019_community <> community
    MATCH (outc)-[:SUMMER_2019]->(start)
    MATCH (outc)-[:FALL_2019]->(end)
    MATCH p=(start)-[:NEXT*]->(end)
    WITH nodes(p) as txns, s
    UNWIND txns as txn
    MATCH (txn)-[:HAS_ARTICLE]->(a)-[:HAS_SECTION]->(s)
    WITH DISTINCT a
    RETURN collect(a) as outCommunityArticles
}
WITH c, articles, community, inCommunityArticles, outCommunityArticles

-- 커뮤니티 밖 고객들이 구매한 품목을, 원 고객의 커뮤니티 고객들이 구매한 품목에서 제거한다
WITH c, articles, apoc.coll.subtract(inCommunityArticles, outCommunityArticles) as onlyInCommunity
-- 앞 단계에서 얻은 품목 목록에서 원 고객이 구매한 품목을 제거한다
WITH c, apoc.coll.subtract(onlyInCommunity, articles) as notPurchasedButInCommunity
-- 이 품목들 중 10개를 추천으로 제공한다
UNWIND notPurchasedButInCommunity as article
RETURN article.id as id, article.desc as desc
LIMIT 10