013、MongoDB常用操作命令与高级特性深度解析

news/2024/7/7 20:50:36 标签: mongodb, 数据库

目录

MongoDB常用操作命令与高级特性深度解析

1. 数据库操作的深入探讨

1.1 数据库管理

1.1.1 数据库统计信息

1.1.2 数据库修复

1.1.3 数据库用户管理

1.2 数据库事务

2. 集合操作的高级特性

2.1 固定集合(Capped Collections)

2.2 集合验证(Schema Validation)

2.3 Time-To-Live (TTL) 索引

3. 文档操作的高级技巧

3.1 复杂查询

3.1.1 正则表达式查询

3.1.2 数组查询

3.1.3 嵌套文档查询

3.2 高级更新操作

3.2.1 数组操作

3.2.2 条件更新

3.3 批量写操作

4. 索引策略与优化

4.1 复合索引

4.2 文本索引

4.3 地理空间索引

4.4 索引优化技巧

5. 高级聚合操作

5.1 复杂的聚合管道

5.2 使用 $lookup 进行关联查询

5.3 使用 $graphLookup 进行图形查询

5.4 使用 $bucket 进行数据分桶

6. MongoDB的高级特性和最佳实践

6.1 变更流（Change Streams）

6.2 数据加密

6.3 分片策略

6.4 性能优化

6.5 数据模型设计最佳实践

7. 实际应用案例深度剖析：基因组数据库系统

7.1 系统架构

7.2 数据模型优化

7.3 索引策略

7.4 分片策略

7.5 查询优化

7.6 数据导入优化

7.7 性能测试结果

MongoDB常用操作命令与高级特性深度解析

1. 数据库操作的深入探讨

1.1 数据库管理

1.1.1 数据库统计信息
db.stats()

这个命令会返回当前数据库的详细统计信息,包括数据大小、索引大小、集合数量等。输出示例:

{
  "db" : "mydb",
  "collections" : 5,
  "views" : 0,
  "objects" : 1000,
  "avgObjSize" : 255.0,
  "dataSize" : 255000,
  "storageSize" : 290816,
  "numExtents" : 0,
  "indexes" : 7,
  "indexSize" : 151552,
  "fsUsedSize" : 4383506432,
  "fsTotalSize" : 62725623808,
  "ok" : 1
}

这些信息对于监控数据库性能和容量规划非常有用。

1.1.2 数据库修复
db.repairDatabase()

这个命令用于修复损坏的数据库。它会重建所有的集合和索引,但可能会很耗时。在执行此操作之前,建议先进行备份。

1.1.3 数据库用户管理
// 创建用户
db.createUser({
  user: "myuser",
  pwd: "mypassword",
  roles: [ { role: "readWrite", db: "mydb" } ]
})
​
// 删除用户
db.dropUser("myuser")
​
// 修改用户密码
db.changeUserPassword("myuser", "newpassword")
​
// 授予角色
db.grantRolesToUser("myuser", [ { role: "dbAdmin", db: "mydb" } ])
​
// 撤销角色
db.revokeRolesFromUser("myuser", [ { role: "dbAdmin", db: "mydb" } ])

这些命令用于管理数据库用户,对于实现细粒度的访问控制非常重要。MongoDB支持基于角色的访问控制(RBAC),可以精确控制用户对数据库的访问权限。

1.2 数据库事务

从MongoDB 4.0开始,支持多文档事务。以下是一个事务示例:

const session = db.getMongo().startSession();
session.startTransaction();
​
try {
  const accounts = session.getDatabase("mydb").getCollection("accounts");
  accounts.updateOne({ owner: "Alice" }, { $inc: { balance: -100 } });
  accounts.updateOne({ owner: "Bob" }, { $inc: { balance: 100 } });
  
  session.commitTransaction();
  console.log("Transaction successfully committed.");
} catch (error) {
  session.abortTransaction();
  console.log("Transaction aborted due to error: " + error);
} finally {
  session.endSession();
}

这个例子展示了如何在一个事务中执行多个操作,确保数据的一致性。事务特别适用于需要原子性的复杂操作,如资金转账。

注意事项:

  • 事务在副本集和分片集群中都可用,但在分片环境中可能会影响性能。

  • 事务有时间限制,默认为60秒。

  • 事务中的操作应尽量精简,以减少锁定时间。

2. 集合操作的高级特性

2.1 固定集合(Capped Collections)

固定集合是一种特殊类型的集合,它有固定的大小,当达到最大值时,新的文档会覆盖最旧的文档。

db.createCollection("logs", {
  capped: true,
  size: 5242880,
  max: 5000
})

这个命令创建了一个最大大小为5MB,最多包含5000个文档的固定集合。固定集合特别适合存储日志等需要按插入顺序保存并且可以被覆盖的数据。

固定集合的特点:

  • 插入顺序就是自然顺序,非常适合某些类型的日志。

  • 支持高吞吐量的插入操作。

  • 不支持删除操作,但可以调用drop()方法删除整个集合。

  • 不支持分片。

2.2 集合验证(Schema Validation)

MongoDB允许为集合定义验证规则:

db.createCollection("users", {
  validator: {
    $jsonSchema: {
      bsonType: "object",
      required: [ "name", "email", "age" ],
      properties: {
        name: {
          bsonType: "string",
          description: "must be a string and is required"
        },
        email: {
          bsonType: "string",
          pattern: "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$",
          description: "must be a valid email address and is required"
        },
        age: {
          bsonType: "int",
          minimum: 18,
          maximum: 99,
          description: "must be an integer in [ 18, 99 ] and is required"
        },
        gender: {
          enum: [ "Male", "Female", "Other" ],
          description: "can only be one of the enum values and is optional"
        }
      }
    }
  },
  validationAction: "error"
})

这个例子定义了一个带有字段验证的用户集合,确保插入的数据符合预定义的模式。

验证的好处:

  • 确保数据一致性和完整性。

  • 减少应用层的验证逻辑。

  • 提高数据质量。

注意:

  • 验证只在插入和更新操作时执行。

  • 可以设置validationAction为"warn"以允许插入不符合规则的文档,但会记录警告。

  • 对已存在的文档不会进行验证,除非它们被更新。

2.3 Time-To-Live (TTL) 索引

TTL索引允许MongoDB自动删除过期的文档:

db.sessions.createIndex( { "lastModifiedDate": 1 }, { expireAfterSeconds: 3600 } )

这个命令创建了一个TTL索引,文档将在lastModifiedDate字段指定的时间一小时后被自动删除。

TTL索引的应用场景:

  • 会话管理

  • 缓存数据

  • 日志数据

注意:

  • TTL索引只能在单个字段上创建。

  • 删除操作是后台进行的,可能有一定的延迟。

3. 文档操作的高级技巧

3.1 复杂查询

3.1.1 正则表达式查询
db.users.find({ name: /^A/ }) // 查找名字以A开头的用户

正则表达式查询允许进行复杂的字符串匹配。

3.1.2 数组查询
// 查找兴趣包含both "reading" 和 "hiking" 的用户
db.users.find({ interests: { $all: ["reading", "hiking"] } })
​
// 查找至少有3个兴趣的用户
db.users.find({ interests: { $size: 3 } })
​
// 使用$elemMatch查询数组中的元素
db.inventory.find({
  dim_cm: { $elemMatch: { $gt: 22, $lt: 30 } }
})

这些查询展示了MongoDB强大的数组查询能力。

3.1.3 嵌套文档查询
// 查找居住在New York的用户
db.users.find({ "address.city": "New York" })
​
// 使用$elemMatch查询嵌套数组
db.schools.find({
  zipcode: "63109",
  students: { $elemMatch: { school: 102, age: { $gt: 15 } } }
})

这些例子展示了如何查询嵌套文档和数组。

3.2 高级更新操作

3.2.1 数组操作
// 向数组添加元素(如果不存在)
db.users.updateOne(
  { name: "Alice" },
  { $addToSet: { interests: "gardening" } }
)
​
// 从数组中移除元素
db.users.updateOne(
  { name: "Alice" },
  { $pull: { interests: "hiking" } }
)
​
// 更新数组中的特定元素
db.users.updateOne(
  { name: "Alice", "scores.type": "exam" },
  { $set: { "scores.$.value": 95 } }
)

这些操作展示了如何高效地管理文档中的数组字段。

3.2.2 条件更新
// 只有在年龄小于30时才更新
db.users.updateOne(
  { name: "Bob", age: { $lt: 30 } },
  { $set: { status: "young" } }
)
​
// 使用$inc和$min组合
db.products.updateOne(
  { sku: "abc123" },
  {
    $inc: { quantity: -2 },
    $min: { quantity: 0 }
  }
)

这些例子展示了如何进行有条件的更新和原子操作。

3.3 批量写操作

const bulkOps = [
  { insertOne: { document: { name: "Dave", age: 28 } } },
  { updateOne: { filter: { name: "Alice" }, update: { $inc: { age: 1 } } } },
  { deleteOne: { filter: { name: "Charlie" } } },
  { replaceOne: { filter: { name: "Bob" }, replacement: { name: "Robert", age: 32 }, upsert: true } }
];
​
db.users.bulkWrite(bulkOps, { ordered: false });

这个例子展示了如何在一个操作中执行多个写入任务,提高效率。ordered: false选项允许MongoDB并行执行这些操作,进一步提高性能。

注意:

  • 批量写操作可以大大提高写入效率,特别是在需要执行大量小型写操作时。

  • 使用ordered: false可以提高性能,但要注意操作之间的依赖关系。

  • 批量写操作支持原子性,即使部分操作失败,也可以回滚所有更改。

4. 索引策略与优化

4.1 复合索引

db.users.createIndex({ age: 1, name: 1 })

这个索引支持按年龄排序的查询,以及年龄和姓名的组合查询。

复合索引的设计原则:

  1. 最常用的查询字段放在前面。

  2. 等值查询的字段放在范围查询字段之前。

  3. 排序字段应包含在索引中。

4.2 文本索引

db.articles.createIndex({ content: "text" })
​
// 使用文本索引进行全文搜索
db.articles.find({ $text: { $search: "MongoDB tutorial" } })
​
// 文本搜索并按相关性排序
db.articles.find(
  { $text: { $search: "MongoDB tutorial" } },
  { score: { $meta: "textScore" } }
).sort({ score: { $meta: "textScore" } })

文本索引支持高效的全文搜索。

注意:

  • 每个集合只能有一个文本索引。

  • 文本索引可能会占用大量存储空间。

4.3 地理空间索引

db.places.createIndex({ location: "2dsphere" })
​
// 查找附近的地点
db.places.find({
  location: {
    $near: {
      $geometry: {
        type: "Point",
        coordinates: [ -73.9667, 40.78 ]
      },
      $maxDistance: 1000
    }
  }
})
​
// 查找在多边形内的地点
db.places.find({
  location: {
    $geoWithin: {
      $geometry: {
        type: "Polygon",
        coordinates: [[
          [ -73.9, 40.8 ],
          [ -73.9, 40.7 ],
          [ -74.0, 40.7 ],
          [ -74.0, 40.8 ],
          [ -73.9, 40.8 ]
        ]]
      }
    }
  }
})

地理空间索引支持基于位置的查询,对于开发位置服务的应用非常有用。

4.4 索引优化技巧

  • 使用 explain() 分析查询性能

db.users.find({ age: { $gt: 30 } }).explain("executionStats")

这会提供详细的查询执行统计信息,帮助识别性能瓶颈。

  • 定期检查索引使用情况,删除未使用的索引

db.collection.aggregate([
  { $indexStats: {} }
])

这个命令可以显示每个索引的使用统计信息。

  • 对于大集合,考虑在后台创建索引

db.users.createIndex({ email: 1 }, { background: true })

后台创建索引不会阻塞其他数据库操作。

  • 使用覆盖索引来提高查询效率

db.users.find({ age: { $gt: 30 } }, { _id: 0, name: 1, age: 1 })

如果有一个包含age和name字段的索引,这个查询可以完全由索引覆盖,无需访问文档。

  • 使用部分索引减少索引的大小

db.restaurants.createIndex(
  { cuisine: 1, name: 1 },
  { partialFilterExpression: { rating: { $gt: 5 } } }
)

这个索引只包含评分大于5的餐厅，可以显著减少索引大小。

部分索引的优势：

  • 减少索引的存储空间

  • 提高索引的效率

  • 降低索引维护的开销

注意：使用部分索引时，查询必须包含索引的过滤条件才能使用该索引。

5. 高级聚合操作

5.1 复杂的聚合管道

db.orders.aggregate([
  { $match: { status: "completed", orderDate: { $gte: new Date("2023-01-01") } } },
  { $group: {
      _id: { $dateToString: { format: "%Y-%m-%d", date: "$orderDate" } },
      totalRevenue: { $sum: "$total" },
      averageOrder: { $avg: "$total" },
      orderCount: { $sum: 1 }
  }},
  { $sort: { totalRevenue: -1 } },
  { $limit: 10 },
  { $project: {
      date: "$_id",
      totalRevenue: { $round: ["$totalRevenue", 2] },
      averageOrder: { $round: ["$averageOrder", 2] },
      orderCount: 1,
      _id: 0
  }}
])

这个聚合管道执行以下操作：

  1. 筛选已完成的订单和2023年之后的订单

  2. 按日期分组，计算每天的总收入、平均订单金额和订单数量

  3. 按总收入降序排序

  4. 限制结果为前10条

  5. 重塑输出格式，包括四舍五入金额到小数点后两位

5.2 使用 $lookup 进行关联查询

db.orders.aggregate([
  {
    $lookup: {
      from: "customers",
      localField: "customerId",
      foreignField: "_id",
      as: "customerInfo"
    }
  },
  { $unwind: "$customerInfo" },
  {
    $project: {
      orderId: 1,
      total: 1,
      "customerInfo.name": 1,
      "customerInfo.email": 1
    }
  }
])

这个例子展示了如何使用 $lookup 来关联订单和客户信息。

$lookup 的高级用法：

db.orders.aggregate([
  {
    $lookup: {
      from: "inventory",
      let: { order_item: "$item", order_qty: "$quantity" },
      pipeline: [
        { $match:
           { $expr:
              { $and:
                 [
                   { $eq: [ "$item",  "$$order_item" ] },
                   { $gte: [ "$instock", "$$order_qty" ] }
                 ]
              }
           }
        },
        { $project: { item: 1, instock: 1 } }
      ],
      as: "inventoryDocs"
    }
  }
])

这个高级 $lookup 示例展示了如何使用管道在关联过程中执行复杂的匹配和转换。

5.3 使用 $graphLookup 进行图形查询

db.employees.aggregate([
  {
    $graphLookup: {
      from: "employees",
      startWith: "$reportsTo",
      connectFromField: "reportsTo",
      connectToField: "_id",
      as: "reportingHierarchy",
      maxDepth: 5,
      depthField: "level"
    }
  }
])

这个聚合操作可以查询员工的完整报告链，最多追溯5级，并记录每个员工在层级中的深度。

$graphLookup 的应用场景：

  • 组织结构查询

  • 社交网络关系分析

  • 产品类别层次结构

5.4 使用 $bucket 进行数据分桶

db.sales.aggregate([
  {
    $bucket: {
      groupBy: "$amount",
      boundaries: [ 0, 100, 500, 1000, Infinity ],
      default: "Other",
      output: {
        "count": { $sum: 1 },
        "total": { $sum: "$amount" },
        "avg": { $avg: "$amount" }
      }
    }
  }
])

这个聚合操作将销售数据按金额分成不同的桶，并计算每个桶的统计信息。

6. MongoDB的高级特性和最佳实践

6.1 变更流（Change Streams）

变更流允许应用程序实时监控数据库的变化：

const changeStream = db.collection('users').watch();
changeStream.on('change', (change) => {
  console.log(change); // 输出变更信息
});

变更流的高级用法：

const pipeline = [
  { $match: { 'fullDocument.status': 'active' } },
  { $project: { 'fullDocument.name': 1, 'fullDocument.email': 1 } }
];
​
const changeStream = db.collection('users').watch(pipeline);
changeStream.on('change', (change) => {
  console.log(change.fullDocument);
});

这个例子展示了如何使用聚合管道来过滤和转换变更事件。

变更流的应用场景：

  • 实时数据同步

  • 缓存失效

  • 事件驱动架构

6.2 数据加密

MongoDB企业版提供静态加密和传输加密：

db.createCollection("sensitiveData", {
  encryptedFields: {
    fields: [
      {
        path: "ssn",
        keyId: UUID("12345678-1234-1234-1234-123456789012"),
        bsonType: "string",
        queries: { "equalTo": true }
      }
    ]
  }
})

这个例子创建了一个集合，其中的 ssn 字段会被自动加密。

加密的最佳实践：

  • 使用强密钥管理系统

  • 定期轮换加密密钥

  • 只加密真正敏感的数据，以平衡性能和安全性

6.3 分片策略

对于大规模数据，MongoDB的分片功能可以提供水平扩展能力：

sh.enableSharding("mydb")
sh.shardCollection("mydb.users", { "userId": "hashed" })

这个命令对 users 集合按 userId 的哈希值进行分片。

分片的考虑因素：

  • 选择合适的分片键（shard key）

  • 避免热点分片

  • 考虑数据本地性

  • 平衡查询分布和写入分布

6.4 性能优化

  • 使用适当的写入关注（Write Concern）和读取关注（Read Concern）

db.collection.insertOne(
  { item: "example" },
  { writeConcern: { w: "majority", wtimeout: 5000 } }
)
​
db.collection.find().readConcern("majority")

  • 使用投影来减少网络传输

db.users.find({}, { name: 1, email: 1, _id: 0 })

  • 使用 $hint 强制使用特定索引

db.users.find({ age: { $gt: 30 }, city: "New York" })
         .hint({ age: 1, city: 1 })

  • 使用 allowDiskUse 处理大型聚合操作

db.orders.aggregate([
  // 复杂的聚合管道
], { allowDiskUse: true })

  • 定期运行 db.runCommand({ compact: 'collectionName' }) 来碎片整理和回收空间

6.5 数据模型设计最佳实践

  1. 嵌入 vs 引用：根据数据访问模式选择适当的模型

  2. 避免过深的嵌套：通常不超过3层

  3. 适当反规范化：提高读取性能

  4. 考虑文档增长：预留足够空间或使用桶设计模式

  5. 使用数组时要小心：大型数组可能导致性能问题

7. 实际应用案例深度剖析：基因组数据库系统

让我们深入探讨Wang等人(2019)的GenomeDB系统[1]，并讨论其架构设计和实现细节。

7.1 系统架构

GenomeDB采用了分布式架构，主要包括以下组件：

  1. 数据导入模块

  2. 查询处理模块

  3. 数据存储层（MongoDB分片集群）

  4. 缓存层（Redis）

  5. 负载均衡器（HAProxy）

7.2 数据模型优化

研究人员对基因变异数据模型进行了优化，以平衡查询效率和存储效率：

{
  _id: ObjectId("..."),
  chrom: "1",
  pos: 1000000,
  ref: "A",
  alt: "G",
  freq: 0.01,
  anno: {
    gene: "BRCA1",
    effect: "missense_variant",
    impact: "MODERATE"
  },
  samples: [
    { id: "SAMPLE001", gt: "0/1" },
    { id: "SAMPLE002", gt: "0/0" }
  ]
}

注意事项：

  • 使用简短的字段名（如 chrom 而不是 chromosome）来减少存储空间

  • 将频繁一起查询的字段（如注释信息）组合到子文档中

  • 对于样本数据，只存储必要的信息

7.3 索引策略

GenomeDB使用了多层次的索引策略：

// 主索引
db.variants.createIndex({ chrom: 1, pos: 1 })
​
// 频率索引
db.variants.createIndex({ freq: 1 })
​
// 基因索引
db.variants.createIndex({ "anno.gene": 1 })
​
// 复合索引用于常见查询模式
db.variants.createIndex({ chrom: 1, pos: 1, "anno.effect": 1, freq: 1 })
​
// 文本索引用于全文搜索
db.variants.createIndex({ "anno.gene": "text", "anno.effect": "text" })

7.4 分片策略

GenomeDB采用了基于染色体的分片策略：

sh.enableSharding("genomdb")
sh.shardCollection("genomdb.variants", { chrom: 1, pos: 1 })

这确保了同一染色体的数据位于同一分片，提高了局部查询的效率。

7.5 查询优化

研究人员实现了一些高级的查询优化技术：

  1. 查询重写：将复杂查询转化为更高效的形式

  2. 结果缓存：使用Redis缓存常见查询的结果

  3. 并行查询执行：将大型查询拆分成多个子查询并行执行

例如，对于跨越多个染色体的查询：

async function parallelChromosomeQuery(query, chromosomes) {
  const promises = chromosomes.map(chrom => 
    db.variants.find({ ...query, chrom: chrom }).toArray()
  );
  const results = await Promise.all(promises);
  return results.flat();
}

7.6 数据导入优化

为了处理大规模数据导入，研究人员采用了以下策略：

  1. 批量插入：使用insertMany而不是单条插入

  2. 并行导入：按染色体分割数据，并行导入不同分片

  3. 索引预创建：在导入数据之前创建所需的索引

  4. 写入关注点优化：在导入阶段使用较低的写入关注点，提高性能

const bulkOps = [];
for (const variant of variantBatch) {
  bulkOps.push({ insertOne: { document: variant } });
  if (bulkOps.length === 1000) {
    await db.variants.bulkWrite(bulkOps, { ordered: false, w: 0 });
    bulkOps.length = 0;
  }
}
if (bulkOps.length > 0) {
  await db.variants.bulkWrite(bulkOps, { ordered: false, w: 0 });
}

7.7 性能测试结果

Wang等人的研究报告了以下性能指标：

  1. 数据导入速度：平均每秒插入50,000个变异记录

  2. 点查询响应时间：< 10ms

  3. 范围查询响应时间（1Mb区域）：< 100ms

  4. 全基因组扫描：< 5分钟

这些结果表明，基于MongoDB的GenomeDB系统能够有效处理大规模基因组数据，为研究人员提供快速、灵活的数据访问能力。


http://www.niftyadmin.cn/n/5535334.html

相关文章

西门子设备对接 C#示例

西门子设备对接 C#示例

要与西门子设备进行对接&#xff0c;可以使用Siemens提供的S7.Net库来进行PLC&#xff08;可编程逻辑控制器&#xff09;的通信。以下是一个简单的C#代码示例&#xff0c;展示如何使用S7.Net库与西门子PLC进行连接和读写数据。 首先&#xff0c;确保你已经安装了S7.Net库。你可…
阅读更多...
2024最新！将mysql的数据导入到Solr

2024最新！将mysql的数据导入到Solr

Solr导入mysql的数据 如何安装导入数据前准备配置Solr的Jar包以及Mysql驱动包1.1、将solr-8.11.3\dist下的两个包进行移动1.2、将mysql-connect包也移动到该位置1.3、重启Solr项目 配置xml2.1、第一步我们需要创建核心2.2、第二步修改xml(这里是结合19年的教程)2.3、 创建data-…
阅读更多...
独一无二的设计模式——单例模式（Java实现）

独一无二的设计模式——单例模式（Java实现）

1. 引言 亲爱的读者们&#xff0c;欢迎来到我们的设计模式专题&#xff0c;今天的讲解的设计模式&#xff0c;还是单例模式哦&#xff01;上次讲解的单例模式是基于Python实现&#xff08;独一无二的设计模式——单例模式&#xff08;python实现&#xff09;&#xff09;的&am…
阅读更多...
基于Hadoop平台的电信客服数据的处理与分析③项目开发：搭建基于Hadoop的全分布式集群---任务7：格式化并启动Hadoop集群

基于Hadoop平台的电信客服数据的处理与分析③项目开发：搭建基于Hadoop的全分布式集群---任务7：格式化并启动Hadoop集群

任务描述 任务内容为格式化并启动Hadoop集群&#xff0c;并修复可能出现的Bug。 任务指导 Hadoop集群启动前需要在NameNode上格式化元数据&#xff0c;成功格式化后才能启动Hadoop的HDFS和YARN。 格式化启动Hadoop集群的步骤如下&#xff1a; 1. 在NameNode&#xff08;ma…
阅读更多...
【Python机器学习】算法链与管道——通用的管道接口

【Python机器学习】算法链与管道——通用的管道接口

Pipeline类补单可以用于预处理和分类&#xff0c;实际上还可以将任意数量的估计器连接在一起。例如&#xff0c;我们可以构建一个包含特征提取、特征选择、缩放和分类的管道&#xff0c;总共有4个步骤。同样的&#xff0c;最后一步可以用聚类或回归代替。 对于管道中估计器的唯…
阅读更多...
基于 Gunicorn + Flask + Docker 的模型高并发部署

基于 Gunicorn + Flask + Docker 的模型高并发部署

在现代 Web 应用程序中&#xff0c;处理高并发请求是一个常见且重要的需求。本文将介绍如何使用 Gunicorn、Flask 和 Docker 来实现模型的高并发部署。我们将从环境设置、代码实现、Docker 镜像构建及部署等方面进行详细讲解。 一、环境设置 1. 安装 Flask 首先&#xff0c;…
阅读更多...
LLaVA1.5训练数据和时间分析

LLaVA1.5训练数据和时间分析

LLaVA的PT+SFT训练_llava sft-CSDN博客文章浏览阅读379次。这个阶段，使用8个A100（80G）训练LLaVA-v1.5-13B大约需要20h。全量微调，非lora跑不起来啊,以前一直用swift，llama-factory这种框架式的代码库，但用原作者开源的代码也是有很多好处的。在这个阶段，使用 8 个 A100（…
阅读更多...
微信小程序 DOM 问题

微信小程序 DOM 问题

DOM 渲染问题 问题 Dom limit exceeded, please check if theres any mistake youve made.测试页面 1 <template><scroll-view scroll"screen" style"width: 100%;height: 100vh;" :scroll-y"true" :scroll-with-animation"tru…
阅读更多...
最新文章

Copyright @ 2022~2023