首页
学习
活动
专区
圈层
工具
发布
首页
学习
活动
专区
圈层
工具
MCP广场
社区首页 >专栏 >AI 创作日记 | DeepSeek 构建知识图谱实战,从零搭建新零售商品关系网络的5个关键步骤

AI 创作日记 | DeepSeek 构建知识图谱实战,从零搭建新零售商品关系网络的5个关键步骤

原创
作者头像
叶一一
发布于 2025-04-01 02:14:49
发布于 2025-04-01 02:14:49
51600
代码可运行
举报
文章被收录于专栏:AI 创作日记AI 创作日记
运行总次数:0
代码可运行

一、导言:新零售时代的认知革命

1.1 新零售场景特性

1.2 传统方案的不足

  • 静态关系库无法反映实时变化
  • 人工规则维护成本高
  • 缺少跨渠道的关联分析

1.3 新零售知识图谱

如何从这些数据中挖掘出有价值的信息,构建清晰的商品关系网络,成为了提升企业竞争力的关键。知识图谱作为一种强大的知识表示和推理工具,能够将商品之间的复杂关系以图形化的方式清晰呈现,为企业的决策提供有力支持。

本文将基于DeepSeek技术栈,详解构建新零售知识图谱的五个关键技术步骤。

二、技术架构设计

2.1 系统架构图

2.2 技术组件选型

模块

技术栈

特性

数据处理

Apache Flink

流批一体处理

实体识别

spaCy + BiLSTM-CRF

动态实体扩展

关系抽取

BERT-Relation

上下文感知

图存储

Neo4j 5.0

原生图计算

可视化

Gephi

动态关系渲染

三、五步构建法详解

3.1 多源数据融合

3.1.1 数据来源分析

新零售企业的数据来源广泛,主要包括以下几个方面:

  • 企业内部数据库:包含商品的基本信息,如商品名称、品牌、规格、价格、库存等;销售记录,如销售时间、销售数量、销售金额等;以及用户的购买历史、会员信息等。
  • 电商平台:如果企业在电商平台上销售商品,平台会提供丰富的数据,如商品的评价、用户的浏览记录、搜索关键词等。
  • 社交媒体:社交媒体上用户对商品的讨论、分享、评价等内容,能够反映出商品的口碑和市场趋势。
  • 第三方数据提供商:可以购买一些专业的数据,如行业报告、市场调研数据等,以补充企业内部数据的不足。

3.1.2 模块架构设计

3.1.3 核心代码实现

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
class DataIntegrator:
    def __init__(self):
        # 多协议数据源连接
        self.sources = {
            'transaction': KafkaConsumer('pos_logs', 
                auto_offset_reset='latest',
                consumer_timeout_ms=1000),
            'inventory': RESTClient('http://wms/api',
                retries=3,
                timeout=5),
            'user_behavior': WebSocket('/user-events',
                ping_interval=30)
        }

    def _normalize(self, raw_data):
        """多模态数据标准化(关键路径)"""
        # 货币单位统一(支持12种货币转换)
        normalized = {}
        if raw_data.get('currency'):
            normalized['amount'] = self._convert_currency(
                raw_data['amount'],
                raw_data['currency']
            )
        
        # 时间维度统一(处理6种时间格式)
        ts = self._parse_timestamp(raw_data['timestamp'])
        normalized['timestamp'] = ts.isoformat()
        
        # 地理坐标转换(WGS84 -> GCJ02if 'location' in raw_data:
            normalized['coord'] = coordinate_transform(
                raw_data['location'],
                src='WGS84',
                dst='GCJ02'
            )
        
        return {**raw_data, **normalized}

    def generate_triples(self):
        """实时三元组生成流水线"""
        while True:
            # 多源数据并行获取
            batch = []
            for source in self.sources.values():
                try:
                    msgs = source.poll(timeout=100)
                    batch.extend([self._process(msg) for msg in msgs])
                except Exception as e:
                    logger.error(f"数据源{source}异常: {str(e)}")
            
            # 时空去重(5维去重策略)
            deduped = self._deduplicate(batch)
            
            # 生成三元组(支持动态schema)
            for data in deduped:
                yield (
                    data['subject'],
                    data['predicate'],
                    data['object']
                )

3.1.4 关键技术解析

1、时空去重算法

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
def _deduplicate(self, batch):
    """五维去重策略"""
    dedup_cache = {}
    for item in batch:
        # 构建复合键:时间+空间+主体+事件类型+数据源
        key = (
            item['timestamp'][:10],  # 日期级
            round(item['coord'][0],2),  # 0.01度精度
            item['subject'],
            item['event_type'],
            item['source']
        )
        if key not in dedup_cache:
            dedup_cache[key] = item
    return list(dedup_cache.values())

去重维度

1. 时间维度:天级粒度

2. 空间维度:经纬度0.01度(约1公里)

3. 业务主体:用户/商品ID

4. 事件类型:购买/浏览/加购等

5. 数据来源:区分原始数据源

3.1.5 小结

该数据融合模块作为知识图谱的基础设施,实现了多源异构数据的实时、高效、精准整合,为后续的智能应用提供了高质量的数据血液。

3.2 动态实体识别

3.2.1 架构设计原理

3.2.2 实体类型定义

实体类别

识别方式

示例

标准商品

规则匹配

SKU1234

促销活动

关键词+语义分析

618大促

用户意图

LSTM分类模型

节日礼品采购

3.2.3 核心代码实现

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
class DynamicNER:
    def __init__(self):
        # 初始化基础模型
        self.nlp = spacy.load("zh_core_web_lg")
        
        # 动态实体存储
        self.entity_cache = LRUCache(max_size=10000)
        self.entity_db = RedisConnection()
        
        # 增量训练配置
        self.retrain_interval = 3600  # 每小时重训练
        self.last_retrain = time.time()
        
        # 上下文分析模型
        self.context_analyzer = BertForSequenceClassification.from_pretrained(
            "bert-base-chinese"
        )
    
    def detect_entities(self, text):
        """动态实体识别主流程"""
        # 基础识别
        doc = self.nlp(text)
        entities = []
        
        # 动态识别
        for ent in doc.ents:
            if self._is_unknown_entity(ent):
                # 上下文语义分析
                context_score = self._analyze_context(text, ent)
                
                # 动态实体缓存
                if context_score > 0.7:
                    self._cache_entity(ent)
                    entities.append({
                        'text': ent.text,
                        'label': 'DYNAMIC',
                        'confidence': context_score
                    })
            else:
                entities.append(ent)
        
        # 增量训练触发
        if time.time() - self.last_retrain > self.retrain_interval:
            self._incremental_train()
        
        return entities
    
    def _is_unknown_entity(self, entity):
        """判断是否为未知实体"""
        return entity.label_ not in ['ORG', 'PER', 'LOC']  # 排除基础实体类型
    
    def _analyze_context(self, text, entity):
        """上下文语义分析"""
        inputs = self.context_tokenizer(
            text, 
            return_tensors="pt",
            padding=True,
            truncation=True
        )
        outputs = self.context_analyzer(**inputs)
        return torch.sigmoid(outputs.logits).item()
    
    def _cache_entity(self, entity):
        """缓存动态实体"""
        key = f"entity:{hash(entity.text)}"
        self.entity_cache.set(key, entity.text)
        self.entity_db.sadd("dynamic_entities", entity.text)
    
    def _incremental_train(self):
        """增量训练模型"""
        new_data = self._prepare_training_data()
        self.nlp.update(
            new_data,
            drop=0.2,  # 防止灾难性遗忘
            sgd=self.optimizer,
            losses=self.losses
        )
        self.last_retrain = time.time()

3.2.4 关键技术解析

1、上下文感知机制

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
def _analyze_context(self, text, entity):
    """改进的上下文分析算法"""
    # 构建上下文窗口
    start = max(0, entity.start_char - 20)
    end = min(len(text), entity.end_char + 20)
    context_window = text[start:end]
    
    # 提取语义特征
    features = [
        self._get_semantic_role(entity.text, context_window),
        self._get_syntactic_pattern(entity.text, context_window),
        self._get_cooccurrence_freq(entity.text)
    ]
    
    # 集成学习预测
    return self.ensemble_model.predict(features)

def _get_semantic_role(self, entity, context):
    """语义角色分析"""
    roles = {
        'agent': 0.3,
        'patient': 0.5,
        'location': 0.8
    }
    return roles.get(parse_semantic_role(entity, context), 0)

def _get_cooccurrence_freq(self, entity):
    """共现频率分析"""
    total = self.entity_db.get(f"count:{entity}")
    return math.log(total + 1) if total else 0

创新点:融合语义角色、句法模式和共现频率的三维分析

2、增量学习优化

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
class IncrementalTrainer:
    def __init__(self, model):
        self.model = model
        self.memory_buffer = deque(maxlen=1000)  # 记忆缓冲区
        self.optimizer = AdamW(model.parameters(), lr=5e-5)
    
    def update(self, new_data):
        # 弹性权重巩固(防止灾难性遗忘)
        fisher_matrix = self._calculate_fisher()
        
        # 混合训练数据
        training_data = self.memory_buffer + new_data
        
        # 自定义损失函数
        loss = self._ewc_loss(fisher_matrix)
        loss += F.cross_entropy(outputs, labels)
        
        # 参数更新
        self.optimizer.zero_grad()
        loss.backward()
        self.optimizer.step()
        
        # 更新记忆缓冲区
        self.memory_buffer.extend(new_data)
    
    def _calculate_fisher(self):
        # 计算Fisher信息矩阵
        pass

技术优势:通过弹性权重巩固(EWC)算法保持模型稳定性

3.2.4 小结

该动态实体识别系统通过持续学习和上下文感知,实现了对新零售场景中瞬息万变的实体信息的精准捕捉,为实时决策提供了核心数据支撑。

3.3 上下文感知关系抽取

3.3.1 架构设计原理

3.3.2 核心代码实现

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
class ContextAwareRE:
    def __init__(self):
        # 初始化预训练模型
        self.tokenizer = AutoTokenizer.from_pretrained("bert-base-chinese")
        self.model = AutoModelForSequenceClassification.from_pretrained(
            "bert-base-chinese",
            num_labels=10  # 关系类型数
        )
        
        # 上下文缓存
        self.context_cache = LRUCache(maxsize=1000)
        
        # 上下文分析器
        self.context_analyzer = ContextGraph()
    
    def extract_relations(self, text, entities):
        """上下文感知关系抽取主流程"""
        # 生成候选关系对
        pairs = self._generate_pairs(entities)
        
        relations = []
        for head, tail in pairs:
            # 获取上下文特征
            local_ctx = self._get_local_context(text, head, tail)
            global_ctx = self._get_global_context(head, tail)
            
            # 多粒度特征融合
            combined = self._fuse_features(local_ctx, global_ctx)
            
            # 关系分类
            logits = self.model(**combined).logits
            pred = torch.argmax(logits, dim=-1)
            
            if pred != 'NO_RELATION':
                relations.append({
                    'head': head,
                    'tail': tail,
                    'relation': pred,
                    'confidence': torch.max(F.softmax(logits, dim=-1)).item()
                })
        
        return relations
    
    def _get_local_context(self, text, head, tail):
        """提取局部上下文"""
        # 构建上下文窗口
        start = max(0, head['start'] - 20)
        end = min(len(text), tail['end'] + 20)
        window = text[start:end]
        
        # 编码局部上下文
        inputs = self.tokenizer(
            window,
            return_tensors="pt",
            padding='max_length',
            truncation=True,
            max_length=128
        )
        return inputs
    
    def _get_global_context(self, head, tail):
        """提取全局上下文"""
        # 从知识图谱获取关联实体
        graph_ctx = self.context_analyzer.query(
            f"""
            MATCH (h)-[r*..2]-(t)
            WHERE h.id = '{head['id']}' AND t.id = '{tail['id']}'
            RETURN r
            """
        )
        
        # 从缓存获取历史交互
        cache_key = f"{head['id']}-{tail['id']}"
        history_ctx = self.context_cache.get(cache_key, [])
        
        return {
            'graph': graph_ctx,
            'history': history_ctx
        }
    
    def _fuse_features(self, local, global_ctx):
        """特征融合模块"""
        # 局部特征
        local_features = self.model.bert(**local).last_hidden_state[:,0,:]
        
        # 全局图特征
        graph_emb = self._encode_graph(global_ctx['graph'])
        
        # 历史特征
        history_emb = self._encode_history(global_ctx['history'])
        
        # 动态权重融合
        combined = self.attention_fusion(
            local_features, 
            graph_emb, 
            history_emb
        )
        return combined

3.3.3 关键技术解析

1、多粒度上下文编码

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
def _encode_graph(self, graph_data):
    """图结构编码"""
    # 使用GCN编码子图
    node_embeddings = self.gcn(graph_data)
    return torch.mean(node_embeddings, dim=0)

def _encode_history(self, history):
    """时序上下文编码"""
    # 使用LSTM编码历史交互
    embeddings = [self._get_embedding(h) for h in history]
    lstm_out, _ = self.lstm(torch.stack(embeddings))
    return lstm_out[-1]

def attention_fusion(self, *features):
    """基于注意力的特征融合"""
    query = torch.cat(features, dim=-1)
    keys = self.fusion_linear(query)
    weights = F.softmax(keys, dim=-1)
    return torch.sum(weights * query, dim=0)

代码说明:融合局部文本、全局图结构和时序上下文的3D编码

2、动态上下文缓存

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
class AdaptiveCache:
    def __init__(self, max_size=1000):
        self.cache = OrderedDict()
        self.max_size = max_size
        self.access_counter = defaultdict(int)
    
    def get(self, key):
        if key in self.cache:
            self.access_counter[key] += 1
            self.cache.move_to_end(key)
            return self.cache[key]
        return None
    
    def set(self, key, value):
        if len(self.cache) >= self.max_size:
            # 淘汰策略:访问频率+最近使用
            candidates = list(self.cache.keys())[:self.max_size//10]
            evict_key = min(candidates, 
                key=lambda k: self.access_counter[k])
            del self.cache[evict_key]
            del self.access_counter[evict_key]
        
        self.cache[key] = value
        self.access_counter[key] = 0

淘汰策略:综合访问频率和最近使用时间的混合策略

3.3.4 小结

该上下文感知关系抽取系统通过深度整合多维度上下文信息,显著提升了复杂场景下的关系识别能力,为构建动态演化的新零售知识图谱提供了核心支持。

3.4 时空权重计算

3.4.1 算法设计原理

3.4.2 权重影响因素矩阵

因子

计算公式

业务影响

时间衰减

e^(-λΔt)

促销后关系权重降低

空间邻近

1/(1+仓库层级差)

同仓商品组合率+15%

用户群重叠

Jaccard相似度

跨品类推荐依据

3.4.3 核心代码实现

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
class SpatioTemporalWeighter:
    def __init__(self):
        # 基础权重配置
        self.base_weights = {
            'purchase': 0.85,    # 购买行为
            'view': 0.35,        # 浏览行为  
            'combo': 0.7,        # 组合购买
            'search': 0.25,      # 搜索行为
            'add_to_cart': 0.5   # 加购行为
        }
        
        # 时间衰减参数
        self.decay_rates = {
            'short_term': 0.15,  # 短期衰减
            'mid_term': 0.08,    # 中期衰减
            'long_term': 0.03    # 长期衰减
        }
        
        # 空间增强参数
        self.spatial_factors = {
            'same_warehouse': 1.25,    # 同仓
            'same_region': 1.1,        # 同区域
            'cross_region': 0.9        # 跨区域
        }
    
    def calculate_weight(self, relation_type, context):
        """时空动态权重计算"""
        # 基础权重校验
        if relation_type not in self.base_weights:
            raise ValueError(f"未知关系类型: {relation_type}")
        
        # 时间衰减计算
        time_decay = self._calculate_time_decay(context['timestamp'])
        
        # 空间增强计算
        spatial_boost = self._calculate_spatial_boost(
            context['product1'], 
            context['product2']
        )
        
        # 综合权重计算
        base = self.base_weights[relation_type]
        return base * time_decay * spatial_boost
    
    def _calculate_time_decay(self, event_time):
        """动态时间衰减因子"""
        days_diff = (datetime.now() - event_time).days
        if days_diff <= 7:
            rate = self.decay_rates['short_term']
        elif days_diff <= 30:
            rate = self.decay_rates['mid_term']
        else:
            rate = self.decay_rates['long_term']
        
        return math.exp(-rate * days_diff)
    
    def _calculate_spatial_boost(self, p1, p2):
        """多级空间增强"""
        warehouse_match = same_warehouse(p1, p2)
        region_match = same_region(p1, p2)
        
        if warehouse_match:
            return self.spatial_factors['same_warehouse']
        elif region_match:
            return self.spatial_factors['same_region']
        else:
            return self.spatial_factors['cross_region']

3.4.4 关键技术解析

1、动态时间衰减

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
def _calculate_time_decay(self, event_time):
    """改进的时间衰减函数"""
    hours_diff = (datetime.now() - event_time).total_seconds() / 3600
    
    # 分段衰减策略
    if hours_diff < 24:  # 24小时内
        return 1.0 - 0.15 * (hours_diff / 24)
    elif hours_diff < 168:  # 7天内
        return 0.85 * math.exp(-0.05 * (hours_diff - 24)/24)
    else:  # 超过7return 0.6 * math.exp(-0.02 * (hours_diff - 168)/24)

代码说明

  • 24小时内线性衰减(保持短期敏感性)
  • 7天内指数衰减(平衡中期影响)
  • 长期缓慢衰减(保留历史价值)

2、空间关系网络

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
class SpatialRelationGraph:
    def __init__(self):
        self.graph = nx.Graph()
        self._build_initial_graph()
    
    def _build_initial_graph(self):
        # 加载仓库拓扑数据
        warehouses = Warehouse.objects.all()
        for wh in warehouses:
            self.graph.add_node(wh.id, type='warehouse', region=wh.region)
        
        # 构建运输路线
        routes = TransportRoute.objects.all()
        for route in routes:
            self.graph.add_edge(
                route.source.id,
                route.dest.id,
                weight=route.transit_time
            )
    
    def spatial_proximity(self, p1, p2):
        """计算空间亲密度"""
        try:
            path = nx.shortest_path(
                self.graph, 
                source=p1.warehouse.id,
                target=p2.warehouse.id,
                weight='weight'
            )
            return 1 / (len(path) ** 0.5)
        except nx.NetworkXNoPath:
            return 0

空间关系计算

1. 基于仓库物理位置构建拓扑网络

2. 使用最短路径算法计算空间亲密度

3. 结合运输时效动态调整权重

3.4.5 小结

该时空权重计算模块通过深度融合时间和空间维度特征,实现了对业务关系的动态量化评估,为精准营销、智能补货等场景提供了核心计算能力。

3.5 实时推理应用

3.5.1 架构设计原理

3.5.2 核心代码实现

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
class EnhancedRealTimeInferencer:
    def __init__(self, kg):
        # 知识图谱连接池
        self.kg_pool = KnowledgeGraphPool(kg, max_connections=10)
        
        # 多级缓存系统
        self.cache = TieredCache(
            fast_cache=LRUCache(10000),  # 内存缓存
            slow_cache=RedisCache()      # Redis缓存
        )
        
        # 上下文处理器
        self.context_processor = ContextAnalyzer()
    
    def recommend(self, user_id):
        """增强版实时推荐"""
        # 获取增强上下文
        context = self._get_enhanced_context(user_id)
        
        # 缓存检查
        cache_key = f"rec:{user_id}:{hash(str(context))}"
        if cached := self.cache.get(cache_key):
            return cached
        
        # 动态构建查询
        query = self._build_query(user_id, context)
        
        # 执行图谱查询
        with self.kg_pool.get_connection() as conn:
            results = conn.execute_query(query)
        
        # 后处理结果
        processed = self._post_process(results, context)
        
        # 缓存结果
        self.cache.set(cache_key, processed, ttl=60)
        
        return processed

    def _build_query(self, user_id, context):
        """动态查询构建"""
        base_query = """
        MATCH (u:User {{id: '{user_id}'}})-[r1:{rels}]->(p1:Product)
        WHERE {context_filters}
        WITH u, p1, r1 ORDER BY r1.timestamp DESC LIMIT 50
        MATCH (p1)-[r2:{relation_types}]->(p2:Product)
        WHERE datetime() < r2.valid_period
          AND {spatial_condition}
        RETURN p2.sku, sum(r1.weight * r2.weight * {context_weights}) as score
        ORDER BY score DESC LIMIT {limit}
        """
        
        return base_query.format(
            user_id=user_id,
            rels=self._get_relevant_relations(context),
            context_filters=self._build_filters(context),
            relation_types="|".join(['combo', 'substitute', 'cross_sell']),
            spatial_condition=self._get_spatial_condition(context),
            context_weights=self._calculate_context_weights(context),
            limit=5 + int(context.get('premium', False)*3)  # 付费用户增加推荐数量
        )

3.5.3 关键技术解析

1、动态查询构建

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
def _get_relevant_relations(self, context):
    """基于上下文的关联关系选择"""
    time_based = {
        'morning': ['view', 'search'],
        'evening': ['purchase', 'add_to_cart']
    }.get(context['time_period'], ['view', 'purchase'])
    
    location_based = ['store_view'] if context['in_store'] else []
    
    return list(set(time_based + location_based))

def _get_spatial_condition(self, context):
    """空间过滤条件生成"""
    if context.get('store_id'):
        return f"p2.available_stores CONTAINS '{context['store_id']}'"
    return "1=1"  # 无空间限制

动态要素

  • 时段敏感的关系选择
  • 地理位置过滤
  • 用户身份差异化推荐数量

2、多级缓存策略

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
class TieredCache:
    def __init__(self, fast_cache, slow_cache):
        self.fast = fast_cache
        self.slow = slow_cache
    
    def get(self, key):
        # 先查快速缓存
        if value := self.fast.get(key):
            return value
        # 再查慢速缓存
        if value := self.slow.get(key):
            self.fast.set(key, value)
            return value
        return None
    
    def set(self, key, value, ttl):
        # 双写策略
        self.fast.set(key, value)
        self.slow.set(key, value, ex=ttl)

缓存策略

  • 内存缓存:毫秒级响应,保存热点数据
  • Redis缓存:分布式存储,持久化缓存
  • 自动回填机制

3.5.4 小结

该实时推理系统通过深度融合知识图谱与实时上下文,实现了毫秒级的智能推荐能力,为零售场景下的精准营销提供了核心技术支持。

四、业务落地实践

4.1 商品推荐

知识图谱可以用于商品推荐,根据商品之间的关系为用户推荐相关的商品。以下是一个简单的示例代码:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
from py2neo import Graph

# 连接到Neo4j数据库
graph = Graph("bolt://localhost:7687", auth=("neo4j", "password"))

# 定义用户感兴趣的商品
product_name = 'Apple iPhone 14 Pro Max'

# 查询相关商品
query = f"MATCH (p:product {{name: '{product_name}'}})-[:belongs_to]->(c:category)<-[:belongs_to]-(related:product) WHERE related.name <> '{product_name}' RETURN related.name"
result = graph.run(query)

# 输出推荐商品
for record in result:
    print(record[0])

代码说明

  • Graph("bolt://localhost:7687", auth=("neo4j", "password")):连接到Neo4j数据库。
  • graph.run(query):执行Cypher查询,查找与用户感兴趣的商品属于同一类别的其他商品。
  • print(record[0]):输出推荐的商品名称。

4.2 智能搜索

知识图谱可以用于智能搜索,根据用户的查询意图返回相关的商品信息。以下是一个简单的示例代码:

代码语言:javascript
代码运行次数:0
运行
AI代码解释
复制
from py2neo import Graph

# 连接到Neo4j数据库
graph = Graph("bolt://localhost:7687", auth=("neo4j", "password"))

# 定义用户查询
query = "Apple products"

# 执行查询
result = graph.run(f"MATCH (p:product)-[:belongs_to]->(b:brand {{name: 'Apple'}}) RETURN p.name")

# 输出查询结果
for record in result:
    print(record[0])

代码说明

  • Graph("bolt://localhost:7687", auth=("neo4j", "password")):连接到Neo4j数据库。
  • graph.run(query):执行Cypher查询,查找苹果品牌的商品。
  • print(record[0]):输出查询结果。

五、结语

本文详细介绍了利用DeepSeek从零搭建新零售商品关系网络的五个关键步骤,包括多源数据融合、动态实体识别、上下文感知关系抽取、时空权重计算和实时推理应用。

未来,随着技术的不断发展,DeepSeek在知识图谱构建方面的应用将更加广泛和深入。可以进一步探索如何利用DeepSeek的强大能力,提高实体识别和关系抽取的准确性,优化知识图谱的构建和应用。同时,结合其他先进技术,如深度学习强化学习等,为新零售企业提供更加智能、高效的决策支持。

原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。

如有侵权,请联系 cloudcommunity@tencent.com 删除。

原创声明:本文系作者授权腾讯云开发者社区发表,未经许可,不得转载。

如有侵权,请联系 cloudcommunity@tencent.com 删除。

评论
登录后参与评论
暂无评论
推荐阅读
大数据计数原理1+0=1这你都不会算(六)No.57
照例甩一波链接。 大数据计数原理1+0=1这你都不会算(一)No.47 <- HashSet 大数据计数原理1+0=1这你都不会算(二)No.50 <- BitMap 大数据计数原理1+0=1这你都不会算(三)No.51 <- BloomFilter 大数据计数原理1+0=1这你都不会算(四)No.52 <- B-Tree 大数据计数原理1+0=1这你都不会算(五)No.55 <- B+Tree 今天开始进入一个全新的领域,嗯
大蕉
2018/02/05
6300
大数据计数原理1+0=1这你都不会算(六)No.57
大数据计数原理1+0=1这你都不会算(九)No.64
大数据计数原理1+0=1这你都不会算(一)No.47 <- HashSet 大数据计数原理1+0=1这你都不会算(二)No.50 <- BitMap 大数据计数原理1+0=1这你都不会算(三)No.51 <- BloomFilter 大数据计数原理1+0=1这你都不会算(四)No.52 <- B-Tree 大数据计数原理1+0=1这你都不会算(五)No.55 <- B+Tree 大数据计数原理1+0=1这你都不会算(六)No
大蕉
2018/02/05
5850
大数据计数原理1+0=1这你都不会算(十)No.77
大数据计数原理1+0=1这你都不会算(一)No.47 <- HashSet 大数据计数原理1+0=1这你都不会算(二)No.50 <- BitMap 大数据计数原理1+0=1这你都不会算(三)No.51 <- BloomFilter 大数据计数原理1+0=1这你都不会算(四)No.52 <- B-Tree 大数据计数原理1+0=1这你都不会算(五)No.55 <- B+Tree 大数据计数原理1+0=1这你都不会算(六)No
大蕉
2018/02/05
5310
大数据计数原理1+0=1这你都不会算(十)No.77
大数据计数原理1+0=1这你都不会算(五)No.55
Hello哈,又好久没聊大数据相关的东西了,是不是又忘记了吖?这次聊聊B-树的升级版,B+树。前面的内容小伙伴可以回顾一下。 大数据计数原理1+0=1这你都不会算(一)No.47 <- HashSet 大数据计数原理1+0=1这你都不会算(二)No.50 <- BitMap 大数据计数原理1+0=1这你都不会算(三)No.51 <- BloomFilter 大数据计数原理1+0=1这你都不会算(四)No.52 <- B-Tree 所谓B+树
大蕉
2018/02/05
5800
大数据计数原理1+0=1这你都不会算(五)No.55
大数据计数原理1+0=1这你都不会算(一)No.47
hello哈,大家是不是好久没见到我啦?我也是一直在摸索小伙伴们喜欢看到什么东西,不喜欢看什么东西,还请大家多多支持。为了表示感谢。小蕉在这给你们一鞠躬,二鞠躬,三。事不过三~ 1+0=1你都不会谈什么大数据? 这篇呢,又是开坑之作,这是一个系列,主要会将大数据下的计数原理。说到计数,不知道大家会第一印象想到什么,我估计会是。。数手指。。没错,小蕉从小学开始就开始数手指,所有20以内的加减法很早就掌握了。研表究明,这估计也是我们现在使用十进制的原因,如果我们每个人每只手都有6只手指,那我们可能就用十二进制了
大蕉
2018/02/05
6830
大数据计数原理1+0=1这你都不会算(三)No.51
这是本坑的第三篇,之前已经说了关于 HashSet 和 BitMap 了,这次说说 Bloom Filter 布隆过滤器,要是还不知道前面讲了啥的,可以点一下下面的连接看看。 大数据计数原理1+0=1这你都不会算(一)No.47 大数据计数原理1+0=1这你都不会算(二)No.50 我们都知道BitMap已经非常节省空间了,一个值只需要一个 bit 就可以进行统计了,但是,对于上百亿的数据来说,碰撞率即使非常低,但也不是一个可以忽视的问题了。 当时提出这个问题,一个是因为垃圾电子邮箱,每天少说都有几十
大蕉
2018/02/05
6300
大数据计数原理1+0=1这你都不会算(三)No.51
大数据计数原理1+0=1这你都不会算(四)No.52
这是本坑的第四篇,之前已经说了关于 HashSet 、BitMap 、Bloom Filter 布隆过滤器了,本篇主要讲B-树。要是还不知道前面讲了啥的,可以点一下下面的连接看看。 大数据计数原理1+0=1这你都不会算(一)No.47 大数据计数原理1+0=1这你都不会算(二)No.50 大数据计数原理1+0=1这你都不会算(三)No.51 B+树是现在很多索引系统的数据结构,而B-树是B+树的基础,本次先讲B-树。 而在讲B-树之前,又不得不讲二叉搜索树(BST,Binary Search Tree)
大蕉
2018/02/05
6400
大数据计数原理1+0=1这你都不会算(四)No.52
大数据计数原理1+0=1这你都不会算(八)No.60
今天跟小伙伴们聊聊另外一个统计算法, Roaring BitMaps。 这个该怎么翻译呢??咆哮的位图?s?我翻译不出来,但是小蕉头一歪,就给它起了一个狂拽酷霸叼扎天的翻译 -> 咆哮吧,位图君们。
大蕉
2018/02/05
8820
大数据计数原理1+0=1这你都不会算(八)No.60
大数据计数原理1+0=1这你都不会算(二)No.50
上一次我们说完了用 HashSet 来进行计数了。我们可以发现,如果我们估计有N个数,那么我们至少需要N*32bit(按照int在32位操作系统下占用32个bit)的空间来进行存储,这太费钱了。有没有
大蕉
2018/02/05
4650
大数据计数原理1+0=1这你都不会算(二)No.50
大数据计数原理1+0=1这你都不会算No.77
完结篇。 这个系列写到这里算是结束了,真是不容易说实话,查了好多好多的资料,真的很难相信懒得要命的我能写完这个系列 T_T。有兴趣的小伙伴可以在菜单看看整个系列。 好啦,开始今天的主题,今天主要呢,聊最后两个基数估计算法,一个是 Adaptive Counting ,一个是 HyperLogLog Counting 。话不多说,直接简单粗暴从 Adaptive Counting 开始吧。 Adaptive Counting 其实就是一个组合算法。原始论文是 《 Fast and accurate traf
企鹅号小编
2018/01/12
6260
大数据计数原理1+0=1这你都不会算No.77
憋瞎说,大数据不是你想的那样 No.114
学生党以及很多没设计过大数据开发的小伙伴呢,都对大数据这么一个领域感到非常非常的好奇非常非常的神秘,我今天就非要戳穿给你们看。
大蕉
2018/10/26
4400
机器学习——经典十大算法之EM算法
EM算法的英文全称是Expectation-maximization algorithm,即最大期望算法,或者是期望最大化算法。EM算法号称是十大机器学习算法之一,听这个名头就知道它非同凡响。我看过许多博客和资料,但是少有资料能够将这个算法的来龙去脉以及推导的细节全部都讲清楚,所以我今天博览各家所长,试着尽可能地将它讲得清楚明白。
TechFlow-承志
2020/04/02
1.9K0
数据科学家成长指南(上)
这才是真正的力量,年轻人! 这是Swami Chandrasekaran所绘制的一张地图。名字叫MetroMap to Data Scientist(数据科学家之路),别称怎么死都不知道的。
Datawhale
2019/09/09
9150
数据科学家成长指南(上)
R语言与点估计学习笔记(EM算法与Bootstrap法)
众所周知,R语言是个不错的统计软件。今天分享一下利用R语言做点估计的内容。主要有:矩估计、极大似然估计、EM算法、最小二乘估计、刀切法(Jackknife)、自助法(Bootstrap)的相关内容。 点估计是参数估计的一个组成部分。有许多的估计方法与估计理论,具体内容可以参见lehmann的《点估计理论》(推荐第一版,第二版直接从UMVU估计开始的) 一、矩估计 对于随机变量来说,矩是其最广泛,最常用的数字特征,母体的各阶矩一般与的分布中所含的未知参数有关,有的甚至就等
机器学习AI算法工程
2018/03/14
2.7K0
R语言与点估计学习笔记(EM算法与Bootstrap法)
【数据分析 R语言实战】学习笔记 第六章 参数估计与R实现(上)
BBsolve()@BB:使用Barzilai-Borwein步长求解非线性方程组
Ai学习的老章
2019/04/10
3K0
【数据分析 R语言实战】学习笔记 第六章 参数估计与R实现(上)
蒙特卡罗(Monte Carlo)方法——从数学原理到实际案例
Monte Carlo方法是一种应用随机数来进行计算机模拟的方法,通过对所研究系统进行随机观察抽样并对样本值进行统计分析,来得到所研究系统的某些参数。
mindtechnist
2025/05/15
1K0
蒙特卡罗(Monte Carlo)方法——从数学原理到实际案例
深度学习面经总结
最近参加社招,面试基本是问项目,然后问项目里的算法所以这里还是按照实际的面试流程展开总结一下,因为做的项目里面对于不同的领域有一些涉及,所以统一整理一下免得临场忘记,当然,主业还是在machine learning上,所以还是以传统机器学习算法为主,时间序列预测,nlp,Graph这些涉及的部分只会总结相关的知识点,就不展开来系统性总结了,没啥太大必要也很麻烦.
人不走空
2024/10/20
1740
深度学习面经总结
数据分析师必掌握的统计学知识!
概率是指的对于某一个特定事件的可能性的数值度量,且在0-1之间。我们抛一枚硬币,它有正面朝上和反面朝上两种结果,通常用样本空间S表示,S={正面,反面},而正面朝上这一特定的试验结果叫样本点。对于样本空间少的试验,我们极易观察出他们样本空间的大小,而对于较复杂的试验,我们就需要学习些计数法则了。
Python数据科学
2019/03/14
9850
数据分析师必掌握的统计学知识!
概率论之概念解析:用贝叶斯推断进行参数估计
【导读】既昨天推出概率论之概念解析:极大似然估计,大家反响热烈,今天专知推出其续集——贝叶斯推断进行参数估计。本文是数据科学家Jonny Brooks-Bartlett概率论基础概念系列博客中的“贝叶斯推断”一章,主要讲解了使用贝叶斯定理进行参数估计的细节。作者使用简单的例子、通俗的语言讲解枯燥的数学公式,博文内容覆盖了贝叶斯定理、贝叶斯公式、共轭先验、贝叶斯推断进行参数估计。这是一篇非常不错的贝叶斯入门文章,如果你对贝叶斯基础有所欠缺,相信你一定能从本文获益良多。 概率论基础概念系列博客——概率论之概念解
WZEARW
2018/04/12
4.4K0
概率论之概念解析:用贝叶斯推断进行参数估计
统计学和大数据如何帮助我们认知世界?
你发现没有,如果你在网上买过东西,商家就会根据你的网购经历,给你推荐很多相关的商品。比方说你买了婴儿奶粉,商家除了给你再推荐奶粉,还会给你推荐婴儿车、婴儿床。还有,你可能也听过,很多互联网公司都会基于后台收集到的各种数据,做出自己产品的“用户画像”,让分散在整个互联网上的用户,从无数抽象的数据,变成一个或者几个具象化的人物,然后再有目的地优化自己的产品。那你知道支撑大数据和算法科技的,是哪一门学科呢?可能你也想到了,对,就是专门处理数据的统计学。
黄成甲
2019/01/03
1.1K0
推荐阅读
相关推荐
大数据计数原理1+0=1这你都不会算(六)No.57
更多 >
目录
  • 一、导言:新零售时代的认知革命
    • 1.1 新零售场景特性
    • 1.2 传统方案的不足
    • 1.3 新零售知识图谱
  • 二、技术架构设计
    • 2.1 系统架构图
    • 2.2 技术组件选型
  • 三、五步构建法详解
    • 3.1 多源数据融合
      • 3.1.1 数据来源分析
      • 3.1.2 模块架构设计
      • 3.1.3 核心代码实现
      • 3.1.4 关键技术解析
      • 3.1.5 小结
    • 3.2 动态实体识别
      • 3.2.1 架构设计原理
      • 3.2.2 实体类型定义
      • 3.2.3 核心代码实现
      • 3.2.4 关键技术解析
      • 3.2.4 小结
    • 3.3 上下文感知关系抽取
      • 3.3.1 架构设计原理
      • 3.3.2 核心代码实现
      • 3.3.3 关键技术解析
      • 3.3.4 小结
    • 3.4 时空权重计算
      • 3.4.1 算法设计原理
      • 3.4.2 权重影响因素矩阵
      • 3.4.3 核心代码实现
      • 3.4.4 关键技术解析
      • 3.4.5 小结
    • 3.5 实时推理应用
      • 3.5.1 架构设计原理
      • 3.5.2 核心代码实现
      • 3.5.3 关键技术解析
      • 3.5.4 小结
  • 四、业务落地实践
    • 4.1 商品推荐
    • 4.2 智能搜索
  • 五、结语
领券
问题归档专栏文章快讯文章归档关键词归档开发者手册归档开发者手册 Section 归档