为什么你的Docker镜像这么胖?slim优化的7个关键步骤

容器镜像优化:Docker Slim与Distroless的镜像瘦身技巧 本文介绍了两种Docker镜像优化技术:Docker Slim和Distroless。Docker Slim通过动态分析和静态扫描自动识别容器运行时实际需要的文件,无需修改Dockerfile即可缩减镜像体积90%以上。Distroless是Google推出的极简镜像,仅包含应用及其运行时依赖,消除Shell环境和调试工具,显著降低攻击面。文章提供了Go和Java应用的优化实例,展示了从650MB到12MB的显著缩减效果,并建议将两种技术结合使用。最后总结了基础镜像选择、构建优化策略和安全加固措施,推荐将优 阅读详情

第一章:Docker镜像臃肿的根源分析

Docker镜像体积过大是容器化实践中常见的问题,直接影响部署效率与资源消耗。镜像臃肿通常源于多层文件系统的叠加、冗余依赖的引入以及构建过程中未优化的操作。

基础镜像选择不当

使用过大的基础镜像(如完整的Ubuntu系统)会显著增加最终镜像体积。应优先选用轻量级镜像,例如 Alpine Linux 或 distroless 镜像。
  • 避免使用 ubuntu:latest 作为基础镜像
  • 推荐使用 alpine 或 gcr.io/distroless/static

构建层未优化

Dockerfile 中每条指令都会生成一个中间层,频繁的文件写入与删除操作会导致层体积膨胀。例如,在安装软件包后未清理缓存:
# 错误示例:未清理包管理器缓存
FROM ubuntu:20.04
RUN apt-get update
RUN apt-get install -y python3

# 正确示例:合并命令并清理缓存
FROM ubuntu:20.04
RUN apt-get update && \
    apt-get install -y python3 && \
    rm -rf /var/lib/apt/lists/*
上述正确示例通过合并命令减少镜像层数,并清除包管理器缓存,有效降低镜像体积。

不必要的文件被包含

在构建过程中,COPY 或 ADD 指令可能引入开发依赖、日志文件或测试数据。应使用 .dockerignore 文件排除无关内容:
文件类型是否应包含说明
node_modules/否应在构建时安装依赖
.git/否版本控制元数据无需打包
tests/否测试代码不用于生产
合理规划构建流程、精简依赖和使用多阶段构建,是控制镜像体积的关键策略。

第二章:基础镜像选择与精简策略

2.1 理解基础镜像的构成与层机制

Docker 镜像是由多个只读层组成的联合文件系统,每一层代表镜像构建过程中的一个步骤。基础镜像通常是这些层的起点,提供操作系统核心组件。
镜像层的叠加机制
每当执行一条 Dockerfile 指令(如 RUN、COPY),就会生成一个新的层。这些层按顺序叠加,上层修改会覆盖下层同名文件,但底层保持不变。
  • 每一层是只读的,确保可复用性
  • 容器启动时在最上层添加一个可写层
  • 删除文件时通过“白名单”机制标记隐藏
Dockerfile 示例与分层分析
FROM alpine:3.18
RUN apk add --no-cache nginx
COPY index.html /var/www/html/
上述代码包含三层:基础 OS 层(alpine)、软件安装层(nginx)、静态文件层(index.html)。每次变更仅重建受影响的层,提升构建效率。

2.2 Alpine、Slim与Nano镜像的对比实践

在容器化部署中,选择轻量基础镜像是优化启动速度与资源占用的关键。Alpine、Slim(如 Debian Slim)和Nano镜像因体积小被广泛采用,但各自在兼容性与安全性上存在权衡。
镜像特性对比
  • Alpine:基于musl libc和BusyBox,体积可低至5MB,但可能因glibc缺失导致二进制兼容问题;
  • Slim:官方Debian/Ubuntu精简版,保留glibc,兼容性强,体积约50MB;
  • Nano:Amazon Linux等提供的极简发行版,介于两者之间,强调安全与维护。
构建示例
FROM alpine:3.18
RUN apk add --no-cache python3
# 注意:需通过apk安装依赖,非apt
该Dockerfile使用Alpine添加Python3,--no-cache避免缓存增大镜像,适用于对体积敏感的服务。
镜像类型典型大小包管理器适用场景
Alpine~5–10MBapk微服务、CI/CD工具镜像
Slim~50MBapt需glibc的传统应用

2.3 使用多阶段构建分离依赖环境

在容器化应用开发中,多阶段构建能有效分离编译环境与运行环境,显著减小最终镜像体积。
构建阶段划分
通过 Docker 的多阶段构建特性,可在同一 Dockerfile 中定义多个 FROM 指令,每个阶段独立运行。
FROM golang:1.21 AS builder
WORKDIR /app
COPY . .
RUN go build -o main ./cmd/api

FROM alpine:latest  
RUN apk --no-cache add ca-certificates
WORKDIR /root/
COPY --from=builder /app/main .
CMD ["./main"]
第一阶段使用 golang:1.21 镜像完成编译,生成可执行文件;第二阶段基于轻量级 alpine 镜像,仅复制编译产物。这样避免将 Go 编译器等开发工具带入生产镜像。
优势分析
  • 减小镜像大小,提升部署效率
  • 增强安全性,减少攻击面
  • 职责分离,构建环境与运行环境解耦

2.4 移除包管理器缓存的实操技巧

在日常系统维护中,包管理器缓存可能占用大量磁盘空间并导致依赖解析异常。定期清理缓存是保障系统稳定与高效的重要操作。
常见包管理器清理命令
  • APT(Debian/Ubuntu):使用以下命令清除下载缓存:

sudo apt clean          # 删除所有已下载的包文件
sudo apt autoclean      # 仅删除过期的包文件

参数说明:clean 彻底清空 /var/cache/apt/archives 目录;autoclean 更安全,仅移除不再可用版本的缓存。

  • YUM/DNF(RHEL/CentOS/Fedora):

sudo dnf clean all      # 清除所有缓存数据

该命令会删除元数据、rpm包缓存及临时文件,推荐在更换镜像源后执行以避免冲突。

2.5 最小化根文件系统中的元数据体积

在嵌入式系统和容器镜像中,根文件系统的大小直接影响启动速度与存储开销。减少元数据体积是优化的关键环节。
移除冗余元信息
许多文件系统默认记录访问时间(atime)、扩展属性等非必要元数据。可通过挂载选项禁用:
mount -o noatime,nodiratime /dev/sda1 /rootfs
该配置避免频繁更新访问时间戳,显著降低日志写入和元数据块修改。
选择精简的文件系统格式
使用专为嵌入式设计的文件系统可有效压缩元数据。例如 SquashFS 采用只读压缩机制,其 inode 结构高度优化。
文件系统平均元数据开销(每文件)
ext4280 bytes
SquashFS42 bytes
构建阶段优化
在制作根文件系统时,使用工具链去除调试符号与冗余描述符:
  • strip --strip-unneeded 清理二进制符号表
  • 删除 /usr/share/doc 等文档目录

第三章:运行时依赖的精准控制

3.1 识别并剔除非必要运行时依赖

在构建轻量级应用时,首要任务是精简运行时依赖。冗余的库不仅增加镜像体积,还可能引入安全漏洞。
依赖分析工具的使用
通过 go mod why 和 go list -m all 可定位模块依赖路径。例如:

go list -deps ./cmd/app | grep 'unwanted-module'
该命令列出应用的所有直接与间接依赖,便于识别未主动调用却仍被加载的包。
常见冗余依赖类型
  • 开发阶段调试工具(如内存分析器)
  • 日志框架的过度封装层
  • 重复功能的第三方JSON解析库
构建阶段依赖剥离策略
使用多阶段构建可有效隔离测试与生产环境依赖:

FROM golang:1.21 AS builder
WORKDIR /app
COPY . .
RUN go build -o app cmd/app/main.go

FROM alpine:latest
RUN apk --no-cache add ca-certificates
COPY --from=builder /app/app .
CMD ["./app"]
上述 Dockerfile 仅将编译产物复制至最小基础镜像,排除所有构建期工具链和测试依赖,显著提升部署效率与安全性。

3.2 动态链接库的裁剪与静态编译权衡

在构建高性能边缘应用时,二进制体积与运行效率之间的平衡至关重要。动态链接库(DLL)可减少内存占用并支持热更新,但引入运行时依赖;静态编译则将所有依赖打包至单一可执行文件,提升部署便捷性与启动速度。
裁剪动态库的常见策略
通过工具如 strip 去除调试符号,结合 upx 压缩可显著减小体积:

strip --strip-unneeded libcustom.so
upx -q libcustom.so
上述命令依次移除冗余符号信息并压缩共享库,适用于资源受限环境。
静态编译的取舍分析
  • 优点:无外部依赖,便于跨平台部署
  • 缺点:体积增大,更新需重新编译整体程序
  • 适用场景:嵌入式设备、安全敏感系统
最终选择应基于部署环境与维护成本综合评估。

3.3 利用strace和ltrace追踪真实依赖

在动态分析二进制程序时,静态检查常无法揭示运行时的真实依赖关系。`strace` 和 `ltrace` 是两款强大的系统级追踪工具,分别用于监控系统调用和动态库函数调用。
strace:追踪系统调用
使用 `strace` 可捕获程序执行期间与内核的交互:
strace -e trace=openat,read,write,execve ./myapp
该命令仅追踪关键系统调用,帮助识别程序访问的文件、创建的进程等行为。例如,`openat` 调用可暴露配置文件或共享库的实际加载路径。
ltrace:追踪动态库调用
`ltrace` 展示程序对共享库函数的调用序列:
ltrace -f -o trace.log ./myapp
参数 `-f` 跟踪子进程,`-o` 将输出重定向至日志文件。通过分析 `malloc`、`pthread_create` 等调用,可还原程序运行时依赖的关键库函数。 结合两者输出,可构建完整的运行时依赖图谱,为容器化或精简部署提供精确依据。

第四章:文件系统层级优化技术

4.1 合并RUN指令以减少镜像层数

Docker 镜像是由多个只读层组成的,每一条 Dockerfile 指令都会创建一个新层。频繁使用 RUN 指令会导致镜像层数激增,增加构建时间和存储开销。
优化前的多层写法
RUN apt-get update
RUN apt-get install -y nginx
RUN apt-get install -y curl
RUN rm -rf /var/lib/apt/lists/*
上述写法生成了 4 个独立层,每一层都保留了前一层的文件状态,造成冗余。
合并 RUN 指令的最佳实践
通过将多个命令合并为一行,利用 shell 的逻辑控制减少层数:
RUN apt-get update && \
    apt-get install -y nginx curl && \
    rm -rf /var/lib/apt/lists/*
该写法仅生成单一层,通过 && 确保命令顺序执行,末尾清理缓存有效减小镜像体积。
  • 减少镜像层数可提升构建效率
  • 合并安装命令能避免中间层残留临时文件
  • 建议在最后清理包管理器缓存

4.2 清理临时文件与中间产物的最佳时机

在构建和部署流程中,临时文件与中间产物的管理直接影响系统稳定性与磁盘利用率。过早清理可能导致依赖缺失,而延迟清理则会占用宝贵资源。
构建完成后立即清理
最安全的策略是在构建或编译任务成功完成后立即清理中间文件。例如,在 Makefile 中使用 `clean` 目标:

build:
    gcc -c main.c -o main.o
    gcc main.o -o program
    rm main.o  # 构建成功后立即清理
该方式确保中间文件仅在必要时存在,降低残留风险。
失败时保留用于调试
可通过条件判断决定是否保留产物:
  • 构建失败时保留临时文件以辅助排查
  • 成功后执行自动清理脚本
结合 CI/CD 流水线的钩子机制(如 post-job cleanup),可实现精准、可靠的资源回收策略。

4.3 使用.dockerignore避免冗余拷贝

在构建 Docker 镜像时,上下文中的所有文件默认都会被发送到守护进程。若不加控制,不仅增加传输开销,还可能引入不必要的缓存失效。
作用机制
.dockerignore 文件类似于 .gitignore,用于指定应排除在构建上下文外的文件和目录,有效减少上下文体积。
典型忽略项
  • node_modules/:依赖目录,通常由 Dockerfile 安装
  • .git/:版本控制元数据
  • logs/:运行日志文件
  • *.log:临时输出文件
# .dockerignore 示例
**/.git
**/node_modules
*.log
.env
Dockerfile
README.md
上述配置可防止敏感信息泄露并提升构建效率。例如,忽略 .env 避免密钥进入镜像;排除 node_modules 确保依赖通过 npm install 正确安装。最终显著缩短构建时间并减小镜像体积。

4.4 压缩技术与镜像分层复用策略

在容器镜像管理中,压缩技术与分层架构的结合显著提升了存储效率与传输性能。通过联合使用内容寻址、差量压缩和共享层机制,系统可在保障完整性的同时减少冗余数据。
镜像分层结构示例
FROM alpine:3.18
COPY . /app
RUN apk add --no-cache python3
CMD ["python3", "/app/hello.py"]
该 Dockerfile 生成的镜像包含四个只读层:基础镜像层、文件复制层、包安装层和启动命令层。每一层基于前一层进行增量修改,实现高效的缓存复用。
压缩与去重优势
  • 各层独立压缩,采用 gzip 或 zstd 算法降低体积
  • 相同基础镜像的容器共享底层数据块,节省磁盘空间
  • 推送时仅上传本地新增层,加快镜像分发速度
图示:多个镜像通过共享 base 层形成树状结构,提升资源利用率

第五章:从理论到生产:slim优化的边界与挑战

在将 slim 框架应用于高并发微服务架构时,性能瓶颈往往出现在序列化与依赖注入层面。某电商平台在使用 slim 进行 API 网关重构后,发现请求延迟在流量高峰期间上升了 35%。通过分析,问题定位在默认的 JSON 序列化器未启用缓存机制。
序列化性能调优
为解决该问题,团队引入了预编译的序列化策略,并结合 PHP OPcache 进行字节码优化:

// 启用 Slim 内置的缓存序列化器
$container['serializer'] = function () {
    return new CachedSerializer(
        new JsonSerializeAdapter(),
        new PhpfastcacheDriver(new FilesPool())
    );
};
依赖注入容器的扩展限制
Slim 的 Pimple 容器虽轻量,但在复杂业务场景下缺乏自动装配能力。某金融系统尝试注入上百个服务时,容器构建时间超过 800ms。解决方案是采用编译时容器生成器,将服务定义提前固化:
  • 使用 PHP-DI Bridge 替代原生容器
  • 通过注解自动生成服务定义文件
  • 在 CI/CD 流程中集成容器编译步骤
中间件链的累积开销
实际压测显示,每增加一个中间件,平均增加 0.3ms 延迟。对于需经过认证、日志、限流等 7 层中间件的请求,总附加延迟接近 2.1ms。为此,团队实施了中间件合并策略:
优化前优化后
7 个独立中间件3 个聚合中间件
平均延迟 2.1ms平均延迟 0.9ms
请求 → [Auth] → [Log] → [RateLimit] → ... → 响应(旧) 请求 → [Security+Log] → [Metrics] → 响应(新)
2.5 Docker镜像优化技巧:多阶段构建让你的镜像体积减少80% Docker镜像优化技巧摘要:通过多阶段构建、选择Alpine等轻量基础镜像、合并RUN指令、利用.dockerignore和编译优化,可将镜像体积减少80%以上。关键技巧包括:构建阶段保留编译工具,运行阶段仅复制必要文件;使用静态编译减少依赖;合并指令减少层数。以Go应用为例,优化后镜像从800MB降至15MB,减少98%。还推荐使用distroless等安全镜像和镜像分析工具持续优化。 阅读详情

相关推荐

Docker基础教程(257)Docker资源控制之镜像瘦身神器Docker Slim:告别“游泳圈”镜像!Docker Slim:你的容器减肥教练,瘦身90%不是梦!

Docker镜像太臃肿,像个带着“游泳圈”的胖子,拖慢部署、浪费资源?是时候请出镜像瘦身黑科技——Docker Slim了!它可不是简单的文件删除工具,而是一位智能“减肥教练”。通过“静态分析”和“动态探测”两大绝技,它能洞察你的应用运行时真正需要的文件,无情剔除文档、调试符号、无用依赖等“脂肪”,轻松实现90%的瘦身奇迹。安全吗?必须的!它会自动设置最小权限,让容器更安全。本文将从原理深度剖析,并附上完整实战示例,带你亲手为一个臃肿的Flask应用“抽脂”,见证从1.2GB到35MB的魔法时刻!

jxf_jxfcsdn的博客 1005

docker瘦身工具之slim

docker镜像大小瘦身项目,建议充分测试后在用于生产,这里有一些官方瘦身的案例,可以作为参考容器优化项目,可以让容器更小、更好、更安全。可以看到案例有缩小了接近30倍的。

菜鸟运维升级之路 2346

DockerSlim(docker-slim):请勿更改Docker容器映像中的任何内容并将其最小化30倍(对于编译后的语言甚至更多),以确保其安全! (免费和开源)-Golang开发

最小化和保护Docker容器(免费和开放源代码!)请勿更改Docker容器映像中的任何内容并将其最小化30倍,以确保其安全性! 继续做自己在做的事情。 无需更改任何内容。 U最小化和保护Docker容器(免费和开源!)请勿更改Docker容器映像中的任何内容并将其最小化30倍,以使其同样安全! 继续做自己在做的事情。 无需更改任何内容。 使用所需的基本图像。 使用所需的程序包管理器。 不用担心手动优化Dockerfile。 您不必扔掉工具和工作流程就可以拥有小的容器映像。 不用担心手动创建Seccomp和AppArmor安全配置文件

docker 镜像瘦身工具 docker-slim

docker-slim的主要作用是对docker镜像进行瘦身的工具。经过瘦身处理的镜像会变小一些甚至变小数倍,且瘦身收仍然可以正常运行。

小单的博客专栏 4896

Go-DockerSlim(docker-slim):优化并保护Docker容器免费和开源

DockerSlim (docker-slim): 优化并保护Docker容器(免费和开源)

开源项目-docker-slim-docker-slim.zip

开源项目-docker-slim-docker-slim.zip,DockerSlim (docker-slim): Optimize and secure your Docker containers (free and open source)

第十七节 Docker Slim之镜像压缩

一、Docker Slim介绍在软件开发和运维领域,Docker已经成为一种常见的容器化解决方案。 然而,随着Docker镜像不断增大,其扩展性和部署效率也逐渐降低。 这时就需要使用Docker Slim来优化镜像,减小其体积和启动时间,提高容器的性能。登录后复制 什么是Docker Slim? Docker Slim是...

weixin_29266749的博客 1450

opencv 常用函数总结

本文是一份OpenCV图像处理的常用函数总结,详细介绍了图像的读入、显示、保存、像素处理、图像属性获取、基础操作、阈值处理、图像平滑、形态学转换以及直方图处理等关键技术。文章通过代码示例和参数说明,帮助读者快速掌握OpenCV在图像处理领域的应用。

weixin_44063529的博客 1599

使用docker-slim为你的docker镜像瘦身

当谈到技术和资源管理时,确实并非所有事物越大越好,这点尤其在 Docker 镜像的管理上体现得淋漓尽致。随着镜像大小的增加,云存储和运维成本也随之增加。因此,有效地减小 Docker 镜像的尺寸对于降低成本和提高效率至关重要。举例来说,以hcymysql/mysql_slowquery:2024-07-04镜像为例,原始文...

cnzzs的博客 1599

Spring Cloud 整合(一) CRUD

Springcloud 整合之 CRUDSpringcloud介绍功能概述为什么要选用Springcloud Springcloud介绍 功能概述 实现微服务 Spring Cloud为开发人员提供了工具,以快速构建分布式系统中的某些常见模式(例如,配置管理,服务发现,断路器,智能路由,微代理,控制总线,一次性令牌,全局锁,领导选举,分布式会话,群集状态)。分布式系统的协调导致样板式样,并且使用Spring Cloud开发人员可以快速站起来实现这些样板的服务和应用程序。 为什么要选用Springcloud

Kerwin-Lin的博客 1501

C#上位机实战:借助NetToPLCSim与西门子S7-1200仿真通信全攻略

本文详细介绍了如何使用C#开发上位机程序,通过NetToPLCSim与西门子S7-1200进行仿真通信的全过程。从环境准备、PLC仿真环境搭建、网络配置到C#代码实现,提供了完整的实战指南和常见问题解决方案,帮助开发者快速掌握工业自动化通信技术。

weixin_30596343的博客 440

rclone test changenotify:探测并验证远端存储变更通知(ChangeNotify)能力

`rclone test changenotify` 是 rclone 内置的测试诊断命令,用于向指定远端注册变更通知(ChangeNotify)回调,并把每次检测到的路径变更以日志形式打印出来。它面向需要验证某个存储后端是否支持变更推送、或需要调试目录缓存失效场景的开发者与高级用户,自 v1.56 引入。读完本文,你将掌握该命令的完整语法与参数、其背后的 `fs.Features.ChangeN

gitblog_00067的博客 1834

NVIDIA NCCL 安装和测试实战教程

ibrary)是用于深度学习应用的高性能通信库,可加速多GPU通信和同步。它能够在多个GPU之间进行高效的数据传输和集体操作,显著提高了分布式GPU系统上深度学习训练和推理的性能。NVIDIA NCCL是加速多GPU系统上深度学习应用的必不可少的工具。其高效的通信原语和集体操作显著提高了分布式训练和推理的性能,使其成为现代深度学习基础架构的关键组成部分。

weixin_39818775的博客 4428

Docker镜像构建性能提升秘籍(slim优化全解析)

掌握Docker镜像构建性能提升核心方法,深入解析Docker镜像的根文件系统优化(slim)。适用于微服务、CI/CD等场景,通过精简基础镜像、多阶段构建实现体积缩减与启动加速,显著降低资源消耗。高效稳定,值得收藏。

LiteProceed的博客 1050

ArcGIS新手必看:HWSD2土壤数据从下载到批量提取TIFF的完整流程

本文详细介绍了ArcGIS中HWSD2土壤数据的完整处理流程,从数据下载、预处理到批量提取TIFF文件。涵盖栅格属性表构建、属性数据连接及性能优化等关键步骤,帮助新手高效掌握HWSD2数据提取技术,提升地理信息数据处理效率。

ll5678的博客 1036

Qwen2.5-7B大模型实战:从零部署到高效推理全流程解析

本文详细解析了Qwen2.5-7B大模型从零部署到高效推理的全流程。内容涵盖环境准备、模型下载、使用Transformers进行核心对话推理,并深入介绍了vLLM与TGI生产级服务部署、GPTQ/AWQ量化技术以降低显存消耗,以及llama.cpp、Ollama等本地推理方案。旨在帮助开发者快速掌握部署技巧,实现大模型在消费级硬件上的高效运行。

weixin_29061425的博客 490

从臃肿到极致轻量,Docker slim镜像优化全流程揭秘

掌握Docker镜像的根文件系统优化(slim)方法,显著降低体积与启动延迟。适用于微服务、CI/CD及资源受限环境,通过多阶段构建、精简基础镜像和依赖剥离实现极致轻量。提升部署效率与安全性,值得收藏。

AlgoChat的博客 838

泛微E9表单建模查询列表勾选后带入流程明细表中

注意:参照下图各项配置,否则会有问题。

泛微二次开发后端知识总结 5309

SLIM容器优化终极指南:一键瘦身Docker镜像,快速提升云原生效率

在云原生时代,容器技术已成为现代应用部署的标准。然而,臃肿的Docker镜像不仅占用大量存储空间和网络带宽,还会增加安全风险。**SLIM容器优化工具**正是为解决这一问题而生,它能将容器镜像大小减小高达30倍,同时自动生成安全配置文件,让你的容器应用更小、更快、更安全! ## 🔍 SLIM是什么? **SLIM**(原名DockerSlim)是一个开源容器优化工具,现已成为CNCF沙箱项目

gitblog_00749的博客 576

华为od 面试八股文_C++_04_含答案

华为od 面试八股文_C++_04_含答案

MISAYAONE的博客 2472

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

Docker镜像瘦身终极指南:docker-slim与dockle双剑合璧

想要打造轻量高效的Jupyter Docker镜像吗?😊 在数据科学和机器学习项目中,Docker镜像的大小直接影响部署速度和存储成本。docker-stacks项目提供了即用型Jupyter应用Docker镜像,但如何进一步优化镜像大小成为开发者关注的重点。本文将为您详细介绍两款强大的Docker镜像优化工具:docker-slim和dockle,帮助您打造极致轻量的容器环境。 ## 为什么

gitblog_01101的博客 663

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

生产Python Docker 镜像选择-Slim 版本(python:3.12-slim)

制作 Python Docker 镜像的最佳实践。不建议使用 Alpine 作为 Python 的基础镜像。

西京刀客 2364

Devexpress16.2.6破解工具

Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具Devexpress16.2.6破解工具

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

【Docker镜像瘦身终极指南】:揭秘slim镜像优化的5大核心技术

掌握Docker镜像瘦身核心技术,解决部署效率难题。深入解析Docker镜像的根文件系统优化(slim),涵盖多阶段构建、精简基础镜像、依赖清理等五大方法,适用于微服务与CI/CD场景,显著减小体积、提升启动速度,值得收藏。

BreakNexus的博客 820

容器瘦身终极指南:SLIM如何实现镜像体积90%缩减?

在容器化部署日益普及的今天,镜像体积过大已成为开发和运维团队面临的普遍痛点。过大的镜像不仅占用更多存储空间,还会导致部署速度缓慢、网络传输成本增加,甚至带来潜在的安全风险。而SLIM(DockerSlim)作为一款免费开源的容器优化工具,能够在不改变容器镜像任何内容的前提下,将其体积缩减高达30倍,对于编译型语言更是能实现90%以上的缩减,同时还能提升容器的安全性。 ## 为什么容器镜像需要瘦身

gitblog_00622的博客 836

Docker 构建镜像安装 python-ldap 报错:slim 镜像缺系统依赖全解析

在 python:3.8.13-slim 镜像中安装 python-ldap 时,因缺少编译器和 OpenLDAP 开发库导致构建失败。根本原因是 slim 镜像未包含 gcc、python3-dev、libldap2-dev 等依赖。解决方案:在 pip install 前通过 apt-get 安装 build-essential、python3-dev、libldap2-dev、libsasl2-dev。生产环境推荐使用多阶段构建,移除编译依赖,减少镜像体积。

00后运维开发实战 | K8s/Docker/自动化分享/Python/MT4/MT5/AI前沿 3901
上一篇: Dify多模态输出解析实战(90%开发者忽略的关键步骤)
下一篇: Docker环境下Nginx反向代理配置避坑指南(附10个真实生产案例)
CompiGlow
博客等级 码龄1年 159粉丝 1987原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值