AI诗歌生成器：基于鸿蒙跨端技术的智能创作系统原创

进修的泡芙

发布于 2025-6-15 11:00

浏览

0收藏

AI诗歌生成器：基于鸿蒙跨端技术的智能创作系统

系统概述

AI诗歌生成器利用鸿蒙分布式技术实现多设备协同的诗歌创作体验，用户可在手机输入关键词，系统自动生成五言/七言诗并在智慧屏优雅展示，同时支持智能手表收藏和分享。该系统结合了先进的NLP技术和鸿蒙跨设备协同能力，为用户提供沉浸式的传统文化体验。

系统架构与核心技术
多设备协作流程：

手机：输入关键词和诗歌类型偏好

云端：运行大型诗歌生成模型

智慧屏：书法风格展示生成的诗句

智能手表：快捷收藏和分享功能
关键技术点：

基于Transformer的诗歌生成模型

分布式任务调度与数据同步

多设备状态一致性管理

书法效果实时渲染

代码实现
分布式服务管理（核心模块）

public class PoemGenerationService extends Ability {
private static final String TAG = “PoemService”;
private DistributedDataManager dataManager;
private PoemGenerator generator;

@Override
public void onStart(Intent intent) {
    super.onStart(intent);
    initDistributedEnv();
    initGenerator();

private void initDistributedEnv() {

    // 初始化分布式能力
    dataManager = DistributedDataManager.getInstance(this);
    
    // 注册数据变化监听
    dataManager.registerDataChangeListener(new DataChangeListener() {
        @Override
        public void onDataChanged(String key, String value) {
            if (key.equals("poem_request")) {
                processPoemRequest(value);

else if (key.equals(“favorite_poem”)) {

                syncFavoritePoem(value);

}

});

private void initGenerator() {

    // 初始化诗歌生成器
    generator = new PoemGenerator(this);
    
    // 加载轻量级模型（完整模型在云端）
    generator.loadLocalModel("poem_generator.tflite");

private void processPoemRequest(String requestJson) {

    PoemRequest request = new Gson().fromJson(requestJson, PoemRequest.class);
    
    // 根据设备能力选择生成方式
    if (request.isComplex() && DeviceManager.hasGoodNetwork()) {
        // 调用云端大模型
        generateWithCloudModel(request);

else {

        // 使用本地轻量模型
        generateWithLocalModel(request);

}

private void generateWithLocalModel(PoemRequest request) {
    String poem = generator.generate(
        request.getKeywords(),
        request.getPoemType(),
        request.getStyle()
    );
    
    // 同步到显示设备
    dataManager.putString("generated_poem", poem);

private void generateWithCloudModel(PoemRequest request) {

    CloudApi.generatePoem(request, new CloudCallback() {
        @Override
        public void onSuccess(String poem) {
            // 缓存到本地
            generator.cacheResult(request, poem);
            
            // 同步到显示设备
            dataManager.putString("generated_poem", poem);

});

private void syncFavoritePoem(String poemJson) {

    // 同步收藏状态到所有设备
    dataManager.putString("favorite_status", poemJson);

}

手机端输入模块

public class PoemInputAbility extends Ability {
private static final String TAG = “PoemInput”;
private DistributedDataManager dataManager;
private TextInput inputKeywords;
private RadioGroup rgPoemType;

@Override
public void onStart(Intent intent) {
    super.onStart(intent);
    initUIComponents();

private void initUIComponents() {

    inputKeywords = findComponentById(ResourceTable.Id_input_keywords);
    rgPoemType = findComponentById(ResourceTable.Id_rg_poem_type);
    
    Button btnGenerate = findComponentById(ResourceTable.Id_btn_generate);
    btnGenerate.setClickedListener(component -> {
        generatePoem();
    });

private void generatePoem() {

    String keywords = inputKeywords.getText();
    String poemType = rgPoemType.getMarkedButton().getText();
    boolean complexRequest = checkComplexRequest(keywords);
    
    PoemRequest request = new PoemRequest(
        keywords, 
        poemType,
        "classic",
        complexRequest
    );
    
    // 发送生成请求
    String json = new Gson().toJson(request);
    dataManager.putString("poem_request", json);
    
    // 显示加载状态
    showLoading();

private boolean checkComplexRequest(String keywords) {

    // 判断是否需要使用云端大模型
    return keywords.split(" ").length > 3 || 
           keywords.matches(".[\\u4e00-\\u9fa5]{4,}.");

private void showLoading() {

    getUITaskDispatcher().asyncDispatch(() -> {
        ProgressBar progress = findComponentById(ResourceTable.Id_progress);
        progress.setVisibility(Component.VISIBLE);
    });

}

智慧屏展示模块

public class PoemDisplayAbility extends Ability {
private static final String TAG = “PoemDisplay”;
private DistributedDataManager dataManager;
private CalligraphyView calligraphyView;
private AnimationController animController;

@Override
public void onStart(Intent intent) {
    super.onStart(intent);
    initDisplayComponents();
    initDistributedListener();

private void initDisplayComponents() {

    calligraphyView = findComponentById(ResourceTable.Id_calligraphy_view);
    calligraphyView.setStyle("regular_script");
    
    animController = new AnimationController(calligraphyView);
    animController.setDuration(2000);

private void initDistributedListener() {

    dataManager = DistributedDataManager.getInstance(this);
    dataManager.registerDataChangeListener(new DataChangeListener() {
        @Override
        public void onDataChanged(String key, String value) {
            if (key.equals("generated_poem")) {
                displayPoem(value);

else if (key.equals(“favorite_status”)) {

                updateFavoriteStatus(value);

}

});

private void displayPoem(String poem) {

    // 书法动画展示
    animController.animateText(poem, new AnimationListener() {
        @Override
        public void onEnd() {
            // 动画结束后显示操作提示
            showOperationTips();

});

private void updateFavoriteStatus(String poemJson) {

    FavoritePoem poem = new Gson().fromJson(poemJson, FavoritePoem.class);
    
    getUITaskDispatcher().asyncDispatch(() -> {
        ImageView ivFavorite = findComponentById(ResourceTable.Id_iv_favorite);
        ivFavorite.setPixelMap(poem.isFavorite() ? 
            ResourceTable.Media.ic_favorite_filled : 
            ResourceTable.Media.ic_favorite_outline);
    });

}

手表端交互模块

public class PoemWatchAbility extends Ability {
private static final String TAG = “PoemWatch”;
private DistributedDataManager dataManager;
private PoemCollector collector;

@Override
public void onStart(Intent intent) {
    super.onStart(intent);
    initCollector();
    initDistributedListener();
    setupGestureControl();

private void initCollector() {

    collector = new PoemCollector(this);

private void initDistributedListener() {

    dataManager = DistributedDataManager.getInstance(this);
    dataManager.registerDataChangeListener(new DataChangeListener() {
        @Override
        public void onDataChanged(String key, String value) {
            if (key.equals("generated_poem")) {
                prepareQuickActions(value);

}

});

private void setupGestureControl() {

    GestureController gesture = new GestureController(this);
    gesture.setSwipeListener(new SwipeListener() {
        @Override
        public void onSwipeLeft() {
            // 向左滑动收藏
            collector.addToFavorite(getCurrentPoem());

@Override

        public void onSwipeRight() {
            // 向右滑动分享
            shareCurrentPoem();

});

private void prepareQuickActions(String poem) {

    getUITaskDispatcher().asyncDispatch(() -> {
        TextButton btnFavorite = findComponentById(ResourceTable.Id_btn_favorite);
        TextButton btnShare = findComponentById(ResourceTable.Id_btn_share);
        
        btnFavorite.setClickedListener(c -> {
            FavoritePoem fav = new FavoritePoem(poem, true);
            String json = new Gson().toJson(fav);
            dataManager.putString("favorite_poem", json);
        });
        
        btnShare.setClickedListener(c -> {
            ShareHelper.shareText(poem);
        });
    });

}

关键技术解析
诗歌生成算法：

  # Python端的诗歌生成核心算法

def generate_poem(keywords, poem_type=“五言”):
# 关键词扩展
expanded_keywords = expand_keywords(keywords)

   # 生成藏头诗或普通诗
   if should_generate_acrostic(keywords):
       return generate_acrostic_poem(keywords, poem_type)
   
   # 使用预训练模型生成
   input_ids = tokenizer.encode(expanded_keywords, return_tensors="pt")
   output = model.generate(
       input_ids,
       max_length=24 if poem_type == "五言" else 32,
       num_beams=5,
       temperature=0.7,
       top_k=50,
       do_sample=True
   )
   
   # 后处理确保符合格律
   poem = tokenizer.decode(output[0], skip_special_tokens=True)
   return adjust_to_metrical_pattern(poem, poem_type)

分布式数据同步：

  // 基于诗歌重要性的同步策略

public void setupSyncPolicies() {
// 生成请求需要可靠传输
SyncPolicy requestPolicy = new SyncPolicy()
.setPriority(SyncPriority.HIGH)
.setDeliveryMode(SyncDeliveryMode.RELIABLE);

   // 生成结果可以容忍轻微延迟
   SyncPolicy resultPolicy = new SyncPolicy()
       .setPriority(SyncPriority.NORMAL)
       .setMaxDelay(200);
   
   // 收藏状态需要即时同步
   SyncPolicy favoritePolicy = new SyncPolicy()
       .setPriority(SyncPriority.CRITICAL)
       .setMaxDelay(50);
   
   dataManager.setSyncPolicy("poem_request", requestPolicy);
   dataManager.setSyncPolicy("generated_poem", resultPolicy);
   dataManager.setSyncPolicy("favorite_poem", favoritePolicy);

书法动画渲染：

  public void animateStroke(Path path, long duration) {
   ValueAnimator animator = ValueAnimator.ofFloat(0, 1);
   animator.setDuration(duration);
   
   animator.addUpdateListener(animation -> {
       float fraction = animation.getAnimatedFraction();
       PathMeasure measure = new PathMeasure(path, false);
       float[] pos = new float[2];
       measure.getPosTan(measure.getLength() * fraction, pos, null);
       
       // 更新画笔位置
       updateBrushPosition(pos[0], pos[1]);
       invalidate();
   });
   
   animator.start();

与游戏昵称同步技术的关联创新
状态同步机制：

借鉴游戏中的关键状态同步策略，确保多设备显示一致的诗歌内容

采用类似游戏中的版本控制处理并发修改
设备角色动态分配：

  // 类似游戏中的角色分配逻辑

public void assignDeviceRoles() {
List<DeviceInfo> devices = DeviceManager.getConnectedDevices();

   devices.forEach(device -> {
       String role = "";
       if (device.hasInputMethod()) {
           role = "input_device";

else if (device.hasLargeScreen()) {

           role = "display_device";

else if (device.isWearable()) {

           role = "interaction_device";

if (!role.isEmpty()) {

           dataManager.putString(device.getId(), "poem_role", role);

});

实时性优化：

关键操作（如收藏）采用即时同步

非关键数据（如生成结果）采用后台异步同步

系统特色功能
多风格生成：

  public void setPoemStyle(String style) {
   switch(style) {
       case "豪放":
           generator.setStyleParams(1.2f, 0.3f);
           break;
       case "婉约":
           generator.setStyleParams(0.8f, 0.7f);
           break;
       case "田园":
           generator.setStyleParams(1.0f, 0.5f);
           break;

}

历史作品回顾：

自动保存用户生成的所有诗歌

按时间线或风格分类浏览
诗人模仿模式：

  def imitate_poet(keywords, poet_name):
   # 加载特定诗人的风格模型
   model = load_poet_model(poet_name)
   
   # 生成具有该诗人风格的诗
   poem = model.generate(keywords)
   
   # 添加诗人特色词汇
   return add_poet_signature_words(poem, poet_name)

该AI诗歌生成器系统通过鸿蒙分布式技术实现了创作、展示、收藏的无缝衔接，借鉴游戏开发中的状态同步和角色分配机制，为用户提供了流畅的跨设备诗歌创作体验。系统既保留了传统诗歌的格律之美，又融入了现代科技的便捷性，让古典文学在数字时代焕发新生。

分类

标签