weixin_42989738的博客

图像去雾毕业论文准备19-深度学习框架（pytorch）— GPU配置成功太棒了，终于出现True了上一节和大家讲了一下，由于放假了，所以我自己还没有做完，中间尝试几次（都中断了）因为网络的原因（注意是国外镜像），所以很慢！尽管我自己知道方法，并且也告诉大家方法，但是没有那么顺利我电脑从武汉邮寄襄阳，今天才到，于是按照之前的方法进行操作，但是一直中断和报错，所以很难受！经过下午的研究，终于搞定了，鉴于之前只是无知的告诉大家如何去做，而自己却没有实施，所以今天把自己做好的记录分享给大家，希望对大家

图像去雾毕业论文准备18-深度学习框架（tensorflow）——深度学习不同版本环境配置之前提到过环境配置的问题，就是不同版本如何共存的，不知道大家有没有操作过，今天我也遇到这个问题了，在此把如何配置不同环境的教程再罗列一遍！之前安装的pytorch里面配置的还有tensorflow环境，然后是2.3版本的，现在看的视频是1.0-2.0之间的版本，所以这里我重新给一个虚拟环境，然后安装一个低版本的环境，开始吧！conda create -n tensorflow python=3.7conda

图像去雾毕业论文准备17-深度学习框架（pytorch）——超级详细（3个小时看完一本书（关键部分））书籍《深度学习框架PyTorch入门与实践》陈云·著书籍有配套的代码，大家可以在github下载，进行演练操作，今天下午（2021年1月8日）用3个小时快速过一遍（自己论文需要的），晚上开始系统学习卷积神经网络，后面开始搜代码进行论文复现。好啦，配置环境的事情前面都已经交代过，就不在罗列了，根据自己电脑的情况，下载安装必要的库！TensorTensor是PyTorch中重要的数据结构，可认为是一个

图像去雾毕业论文准备15-深度学习框架（pytorch）——超级详细（收集数据集）还是之前的那个例子，之前是抽象的进行讲解，本节拆分细讲！线性回归细讲#!/usr/bin/python3.6# -*- coding: utf-8 -*-# @Time : 2021/1/6 11:04# @Author : ptg# @Email : zhxwhchina@163.com# @File : 线性回归分解写法.py# @Software: PyCharm# 导入库imp

图像去雾毕业论文准备14-深度学习框架（pytorch）——超级详细（基础知识）torch常见的数据类型#!/usr/bin/python3.6# -*- coding: utf-8 -*-# @Time : 2021/1/5 21:41# @Author : ptg# @Email : zhxwhchina@163.com# @File : pytorch基础知识.py# @Software: PyCharmimport torch# 0-1之间的均匀分布x

图像去雾毕业论文准备13-深度学习框架（pytorch）——超级详细（线性回归案例讲解）基于上节的介绍，相信你对pytorch有了简单的了解，我是跟着视频，加上个人理解进行本节的讲解，一方面对课程学习进行加深，一方面对可以方便以后查阅复习，同时还可以给有需要的朋友进行参考，实现资源共享！参照上之前tensorflow的学习，下面开始讲解！1 首先导入相关的库文件# 导入库import torchimport numpy as npimport matplotlib.pyplot as plt

图像去雾毕业论文准备11-深度学习框架（pytorch）——超级详细（基础环境）上一篇中已经说明了本节的学习内容，就是对pytorch进行学习，然后开始看卷积相关的内容！动态图和静态图的区别pytorch 和 tensorflow2.0以上差不多，所以为了后面看代码选择性更大，这里把pytorch也简单学习一下，之前已经学习了tensorflow，这里就以此类推进行学习！线性回归：# 导入库import torchimport numpy as npimport matplotl

图像去雾毕业论文准备11-深度学习框架（tensorflow2.0）——超级详细（过拟合、欠拟合）可以使用Dropout抑制过拟合好啦，先了解这么多！后面再看看pytorch，然后开始看卷积（图像相关的），最后开始做代码复现，网络修改，搭建！（完！）...

图像去雾毕业论文准备10-深度学习框架（tensorflow2.0）——超级详细（学习率、反向传播）

#!/usr/bin/python3.6# -*- coding: utf-8 -*-# @Time : 2021/1/3 16:58# @Author : ptg# @Email : zhxwhchina@163.com# @File : tensorflow2.0.py# @Software: PyCharm# 测试是否安装成功import tensorflow as tfimport osimport pandas as pdimport matplotlib

图像去雾毕业论文准备07-深度学习框架（tensorflow2.0）——超级详细，值得一看（梯度下降）寻找梯度值就是寻找下降最快速的路线，使得要求的值最小！学习率：改变的快慢局部极值点：因为是随机初始化操作（所以一般不用思考局部极值）正向传播：反向传播：激活函数激活函数relu：sigmoid激活：tanh激活：Leak Relu:...

图像去雾毕业论文准备06-深度学习框架（tensorflow2.0）参考视频tensorflow2.0学习视频一、简易安装教程CPU版本首先根据要求检查一下自己的pip版本，如果大于19.0就跳过，如果是小于19.0，就使用命令进行更下python -m pip install --upgrade pip安装包下载安装（使用安装豆瓣源）pip install tensorflow-cpu==2.3.0 -i https://pypi.douban.com/simple

图像去雾毕业论文准备05-python中科学计算（NumPy和SciPy)但凡对深度学习有所学习基本上都知道这两个包，尤其是NumPy和裂变类似，但是运行效率又远高于列表，在Pytorchh中，numpy也很重要，废话少说，开干！NumPy 和 SciPy是Python中用以实现科学计算的模块包Numpy主要提供了数组对象、基本的数组函数和傅里叶变换的相关函数。而SciPy依赖与NumPy一、包的安装这个就不介绍了，如果不会可以网上搜下教程，或者放弃学习吧（这两个包很基础，安装也很简单，唯一一点就是

说起异常，做编程的朋友应该都很清楚，异常捕捉和解决是代码鲁棒性的一个基础。好啦，本节为了使得程序的鲁棒性较好，因此在这里进行python异常相关知识的讲解！首先看看几个常见的异常错误：1 AtttibuteError 调用不存在的方法引起的异常2 EOFError 文件末尾引发的异常3 ImportError 导入模块出现的异常4 IndexError 列表越界引发的异常5 NameError 变量名出现的错误6 ValueError 搜索列表中不存在的值引发的错误7 ZeroDivisi

图像去雾毕业论文准备03-python中class（类学习）我们知道C语言和C++语言相比，有一点区别就是，C语言是面向过程的,而C++是面向对象的。Python和C++一样，也是可以面向对象，为什么要学习面向对象，懂编程的朋友都知道吧，操作方便，便于管理。这也是为什么我在做论文时需要提前进行弥补的，因为关于深度学习相关的东西，在搭建网络的时候，大多都需要进行类的使用。所以今天用点时间把class相关的东西简单梳理一下，后面能够看懂别人的代码，最好自己可以进行编写！好啦，闲话少说，看重点吧！不系

OS：operate System 操作系统os模块并不是python启动时的模块导入os模块import os标准库import oshelp(os)1 getcwd()获取当前工作目录print(os.getcwd())输出结果：E:\PycharmSoftware\CNN2 修改当前工作目录os.chdir(“D:/Desktop”)3 获取目录中所有文件或者文件夹的名称result = os.listdir(“D:/Desktop”)print(result[0])4

2021年第一篇博文，很高兴又回到博文！先说说后面我需要做的工作我的毕业论文是《基于卷积神经网络的去雾》关于论文，我打算从以下5章进行展开第1章1.1 背景1.2 国内外研究现状1.3 本文研究步骤第2章介绍雾天模型（暗通道先验理论）因为我写了一篇关于去雾的小论文，所以我打算介绍完雾天模型后，将自己写的小论文中的一些内容用在这里然后对结果进行评价（主观、客观）最后对本文算法的不足进行展望（为深度学习相关做准备）第3章关于第三章，首先我会介绍卷积相关的理论1、卷积层2、池化层

# -*- coding: utf-8 -*-import cv2import numpy as npimport sysdef integral(image): rows,cols = image.shape #行积分运算 inteImageC = np.zeros((rows,cols),np.float32) for r in range(rows): for c in range(cols): if c == 0:

有时候我们没办法得到pdf或者word文档，这个时候会使用手机或者相机进行拍照，往往会出现背景，打印出来就是灰色的或者有黑色的背景，这个时候影响视野观看，通过代码实现对背景去除，还原清晰图像。代码如下：#!/usr/bin/python3.6# -*- coding: utf-8 -*-# @Time : 2020/11/17 19:06# @Author : ptg# @Email : zhxwhchina@163.com# @File : 去背景.py# @Softwar

1 多线程是Python程序中实现多任务的一种方式2 线程是程序执行的最小单元3 同属于一个进程的多个线程共享进程所拥有的全部资源多线程实现多任务1 导入线程模块import threading2 通过线程类创建线程对象线程对象 = threading.Thread(target = 任务名）3 启动线程执行任务线程对象。start()单线程import threadingimport timedef sing(): for i in range(3):

Python前世1989年圣诞节前夕，山雨欲来风满楼，计算机程序设计语言界隐隐有大事要发生，果然不出所料。江湖人称龟叔(Guido von Rossum)，就是这位祖籍荷兰的大牛，在圣诞节百无聊赖的期间，发明了Python。之所以选中Python作为程序的名字，是因为龟叔是BBC电视剧——蒙提·派森的飞行马戏团（Monty Python’s Flying Circus）的爱好者。ABC是由参加设计的一种教学语言。就龟叔本人看来，ABC这种语言非常优美和强大，是专门为非专业程序员设计的。1991年初，

#!/usr/bin/python3.6# -*- coding: utf-8 -*-# @Time : 2020/11/1 21:04# @Author : ptg# @Email : zhxwhchina@163.com# @File : course_02.py# @Software: PyCharmimport cv2import numpy as npdef access_piexl(image): print(image.shape) hei

#!/usr/bin/python3.6# -*- coding: utf-8 -*-# @Time : 2020/10/30 11:06# @Author : ptg# @Email : zhxwhchina@163.com# @File : course_01.py# @Software: PyCharmimport numpy as npimport cv2# 读取视频操作，并显示图片def video_demo(): capture = cv2.V

结构相似形特征(SSIM)原理简介及python实现

1 形态学转换形态学操作是根据图像形状进行的简单操作。一般情况下对二值化图像进行操作。需要输入两个参数，一个原始图像，第二个被称为结构化元素或核，它是用来操作的性质的。两个基本的形态学操作是腐蚀核膨胀。他们的变体构成了开运算，闭运算，梯度等。1.1 腐蚀就像土壤侵蚀一样，这个操作会把前景物体的边界腐蚀掉（但是前景仍然是白色）。这是怎么做到的呢？卷积核沿着图像滑动，如果与卷积核对应的原图像的所有像素值都是1,那么中心元素就保持原来的像素值，否则就变为零。这回产生什么影响呢？根据卷积核的大小靠近前

昨天有事情，本来打算一天分享完的（就是快速看看关键的部分），然后上午看了一会，有事情去忙了，所以没有完成这个工作，今天下午打开一看收到小伙伴的评价，其实自己也是个小白，因为论文的需要，需要图像的知识，自己能力有限，但是会尽力分享每一次学习的心得，希望一方面督促自己学习，另一方面也可以和大家分享交流，做学术嘛，就是要一起学习才能共同进步。感谢小伙伴的支持，谢谢关注！1 图像阈值图像阈值理论代码：import numpy as npimport cv2import matplotlib

前沿我使用的是Pycharm编译器用anaconda配置的解释器安装的库：numpy matplotlib cv2等在进行下面的工作之前，给各位说说pycham中添加个人信息#!/usr/bin/python3.6# -*- coding: utf-8 -*-# @Time : ${DATE} ${TIME}# @Author : super_kun# @Email : xxxxxxxxxxx@xxx.com# @File : ${NAME}.py# @Softwar

四个区#include<stdio.h>#include<stdlib.h>int a; //全局变量的未初始化，默认是0；而局部变量不会，因此，局部变量为未初始化就会报错int main(void){ //int b; printf("a = %d
",a); system("pause"); return 0;}#include<stdio.h>#include<stdlib.h>int a; //全局变量的未初始化

import timestart_time = time.time()for a in range(1,1001): for b in range(1,1001): for c in range(1,1001): if a+b+c == 1000 and a**2 + b**2 == c**2: print("a, b, c:%d,%d,%d"%(a,b,c))end_time = time.time()print(.

TCP ip协议一类协议的统称Mac地址，序列号MAC地址MAC地址是网卡决定的，是固定的交换机发送的时候，第一次是广播地址过去，正确的就会进行返回，不正确的就进行丢弃第二次发送的时候，就是单播发送，就是广播发送正确的那一个互联网浏览器服务器上网...

类classclass Dog(): def __init__(self,name,age): """初始化属性name和age""" self.name = name self.age = age def sit(self): """模拟小狗被命令时蹲下""" print(self.name.title()+"is now sitting.") def roll_over(self):

索引的时候是从0开始而不是从1开始的list = ['track','bus','car']print(list[0].title())# 大写print(id(list))list.append("zhai")print(list)print(id(list))列表使用append的时候，试用前后使用后的id值没有改变list = ['track','bus','car']print(list[0].title())# 大写print(id(list))list.append("z

STL标准模板库容器 算法 迭代器容器和算法之间通过迭代器进行无缝连接容器算法迭代器仿函数vector::iterator itBegin = v.begin();//起始迭代器 指向容器中的第一个元素vector::iterator itEnd = v.end();//结束迭代器 指向的最后一个元素的下一个//通过迭代器访问容器中的数据vector<int>::iterator itBegin = v.begin();//起始迭代器 指向容器中的第一个元素ve

1 ofstream：写操作2 ifstream:读操作3 fstream：读写操作文本文件写文件1包含头文件#include2 创建流对象osrteam ofs3 打开文件ofs.open(“文件打开方式”)4 写数据ofs<“写入的数据”;5 关闭文件ofs.close()文件操作（写文件）1 包含头文件2 创建流3 打开（选用合适的打开模式）4 开始进行读或者写操作5 关闭文件（操作完毕）如果不指定路径的话，默认的情况就在源文件所在目录下生成一个..

静态多态和动态多态以下代码是地址早绑定:#include<iostream>#include<string>using namespace std;class Animal{public: void speak() { cout << "动物在说话" << endl; }};class Cat :public Animal{ void speak() { cout << "猫在说话" <<.

加法用算符重载#include<iostream>#include<string>using namespace std;class Person{public: //1、 成员函数重载+号 Person operator+(Person &p) { Person temp; temp.m_A = this->m_A + p.m_A; temp.m_B = this->m_B + p.m_B; return temp; }

class Person{int m_A;//非静态成员变量 属于类的对象上static int m_B;//静态成员变量 不属于类对象上void func() {} //非静态成员函数 不属于类对象上static void func2() {};//静态成员函数 不属于类的对象上};#include<iostream>#include<string>using namespace std;class Person{ int m_A;//非静态成员变

空指针和野指针都不是我们申请的空间，因此不要访问。常量指针：指针常量：加上const防止误操作，定义成只读类型int* func(){ int a = 10; return &a;//战区的数据在函数执行完毕后自动释放}int main(void){ //栈区注意事项 //不要返回局部变量的地址 int *p = func(); cout << *p << endl;//第一次可以打印正确的数字，是因为编译器作量保留 cout &.

快速排序

一、冒泡排序#include<sys/timeb.h> //这个可以精确到毫秒#define MAX 10000//获取精确的时间函数long getSystemTime(){ struct timeb tb; ftime(&tb); return tb.time * 1000 + tb.millitm;}#include<stdio.h>#include<stdlib.h>#include<string.h>#inc

data next链表：头文件API函数：#pragma once#ifndef LINKLIST_H#define LINKLIST_H#include<stdio.h>#include<stdlib.h>//链表节点typedef struct LINKNODE{ void* data;//无类型指针，可以指向任何类型的数据 struct LINKNODE* next;}LinkNode;//链表结构体typedef struct ..

//耦合度：高内聚 低耦合什么是耦合模块与模块之间有写操作是有关联的， 如果改动一个木块其他的木块都有可能受到影响，模块与模块之间的关系越是紧密，独立性就越不好！例如：如果模块1直接操作了木块2红的数据，这种操作模块与模块之间就为强耦合，甚至可以认为这种情况之下基本算没有分模块！如果1只是通过数据与2模块交互，这种我们称之为弱耦合！微服务独立的模块，方便去维护，或者写单元测试等等…如果木块之间的依赖非常严重，将会非常不易于维护。虚继承...

操作符重载，通过重载，对自定义的数据类型进行操作//…这里是操作符重载，写在全局//...这里是操作符重载，写在全局 Complex operator+(Complex &c1, Complex &c2){ Complex temp(c1.a + c2.a, c1.b + c2.b); return temp;}单目运算符不能写全#include<iostream>#include<cmath>using namespace std;.

如果对一个对象连续调用成员方法，每次都会改变对象本身，成员方法需要返回引用#include<iostream>using namespace std;class Test { public: Test(int a, int b) { this->a = a; this->b = b; } void printT() { cout << "a = " << this->a << " " &.

析构不可以进行重载拷贝函数构造函数是对象初始化的时候调用#include<iostream>#include<cmath>#pragma warning (disable :4996)using namespace std;class Teacher{public: Teacher(int id, char *name) { cout << "int,char *" << endl; m_id = id; i..

#include<iostream>#include<cmath>using namespace std;class Test{public: //test类的构造函数 //在对象呗创建的时候，用来初始化对象的函数 Test(int x, int y) { m_x = x; m_y = y; } //构造函数是可以被重载的 Test(int x) { m_x = x; m_y = 0; } //无参构造构造函数,默认初始值为0

上一讲提到的判断两个圆的关系，通过类实现，看代码：#include<iostream>#include<cmath>using namespace std;//判断两个圆的关系// 点类class Point{public: void setXY(int x, int y) { m_x = x; m_y = y; } //计算两点间的方法 double pointDistance(Point &another) { int d_x

这里定义在类的private下，在类外是没有访问权限的#include<iostream>#pragma warning(disable:4996) //注意这一句的使用，可以解决C语言中出现的一些兼容性问题using namespace std;struct Hero{ char name[10]; int sex;};//这个一定要写在全局中才能实现对于结构体的打印，但是对于类而言，并不是这样的，还可以写在类里面void print_info(struct.

内联函数关键字inline 必须与函数定义体放在一起才能使函数成为内联，仅将inline 放在函数声明前面不起任何作用。慎用内联内联能提高函数的执行效率，为什么不把所有的函数都定义成内联函数？如果所有的函数都是内联函数，还用得着“内联”这个关键字吗？内联是以代码膨胀（复制）为代价，仅仅省去了函数调用的开销，从而提高函数的执行效率。如果执行函数体内代码的时间，相比于函数调用的开销较大，那么效率的收获会很少。另一方面，每一处内联函数的调用都要复制代码，将使程序的总代码量增大，消耗更多的内存空间。

引用和指针的区别★相同点：●都是地址的概念；指针指向一块内存，它的内容是所指内存的地址；而引用则是某块内存的别名。★不同点：●指针是一个实体，而引用仅是个别名；●引用只能在定义时被初始化一次，之后不可变；指针可变；引用“从一而终”，指针可以“见异思迁”；●引用没有const，指针有const，const的指针不可变；具体指没有int& const a这种形式，而const int& a是有的，前者指引用本身即别名不可以改变，这是当然的，所以不需要这种形式，后者指引用所指的..

#include<iostream>using namespace std;struct student{ char name[100]; int age;};//这里结构体是通过指针进行传递的，一般来说就是4个字节void print_info(struct student *p){ cout << "姓名:" << p->name << " " << "年龄:" << p->age <&l

看到这里，你还想搞C++吗？哈哈哈，试试看，应该不会掉头发吧。在C++语言中，随用随定义在C语言中，重复定义多个同名的全局变量是合法的。在C++中，不允许定义多个同名的全局变量。在C语言的struct定义一组变量的集合，C编译器并不认为这是一种新的类型在C++中的struct是一个新的定义声明左值和右值得当左值的条件是，要有内存空间。在C++中三目运算，可以当左值。const常亮是由编译器处理的，提供类型检查和作用阈检查宏定义由预处理器处理，单纯的文本替换。C++枚举，.

今天又回来学习啦，预计今天完成C的学习，晚上开始学习C++和大家简单唠唠嗑，因为现在在秋招，我一开始在做图像处理相关的，当初为了偷懒，不想学习C\C++,选择了python学习，学习过python的小伙伴，一定知道，这个是比较简单的，很多已经被做成了函数和库，可是去找图像相关的工作，对学历、算法要求还有不少，于是找工作很不顺利（当然也是自己学的不精），于是准备转找嵌入式相关的，因为我也有1-2年的嵌入式软件相关的编程，但是忘得差不多了，于是从C开始捡。正在学习的小伙伴也要好好的准备吧，不然以后找工作就很

算法：有穷性确定性可行性数据结构对于面试的时候问的比较多，因此这里需要进行学习，仅仅用C语言进行讲解，对于其他语言都是一样的，只不过是编程的代码不一样而已。#include<stdio.h>int main(void){ int s[10] = { 10,23,34,32,42,12,9,56,21,8 }; int i; printf("排序前："); for (i = 0; i < 10; i++) { printf("%d ",s[i]); } pr

#include<stdio.h>#include<string.h>#include<stdlib.h>#pragma warning(disable:4996) //注意这一句的使用，可以解决C语言中出现的一些兼容性问题enum A{ red, black, yellow //其实就是整数，从0开始0,1,2,3,4,5,6...};int main(){ // yellow = 20;//美剧是常亮，值是不能改变的 int color.

//同一个时刻只使用一个成员，就没必要开辟那么多内存空间去储存结构体变量#include<stdio.h>#include<string.h>#include<stdlib.h>#pragma warning(disable:4996) //注意这一句的使用，可以解决C语言中出现的一些兼容性问题union A{ int a; char b;};int main(){ union A a; a.a = 10; a.b = 20; pri

注意上面的struct stduent{char name[100];int age;}只是定义了一种类型，并不是变量，正式定义变量是在下面开辟空间的时候不能直接使用结构体类型的数组进行->操作，->是针对指针类型而言的。定义的是指针类型的char *name；所以在只是一个地址信息，在使用的时候需要先用malloc进行内存分配才可以进行使用这里有一个重点内容，就是结构体使在堆区开辟的，然后对于结构体里面的成员再进行堆去分配，那么就出现了嵌套的使用情况，那么在释放的时候.

注意：一下赋值是不能使用的但是在结构体中是可以直接进行赋值操作的st[1] = st[2];printf(“姓名 = %s, 年龄 = %d, 班级 = %s, 成绩 = %d
”,st[1].name,st[1].age,st[1].classes,st[1].score);结构体使可以进行互相赋值的struct A a1 = { “hello” };struct A a2 = {“c”};a2 = a1;#include<stdio.h>struct E{ ch

区别:malloc、calloc、realloc的区别(1)函数malloc不能初始化所分配的内存空间,而函数calloc能.如果由malloc()函数分配的内存空间原来没有被使用过，则其中的每一位可能都是0;反之, 如果这部分内存曾经被分配过,则其中可能遗留有各种各样的数据.也就是说，使用malloc()函数的程序开始时(内存空间还没有被重新分配)能正常进行,但经过一段时间(内存空间还已经被重新分配)可能会出现问题.(2)函数calloc() 会将所分配的内存空间中的每一位都初始化为零,...

#include<stdio.h>int a = 20;//全局变量void test1(){ int a1 = 0; int a = 100;}void test2(){ int a2 = 100;}int main(){ int a = 0; a = 10; system("pause"); return 0;}文件中的变量extern int a ;出现在括号外面的变量就是全局变量不写auto变量，C语言默认是auto一般情况下，代码块

字符拷贝拷贝的时候需要注意没有重叠区域

函数指针：#include<stdio.h>int add(int a,int b){ return a + b;}int max(int a, int b){ return a > b ? a : b;}int main(void){ int(*p)(int, int);//定义一个指向函数的指针 int status = 0; printf("请输入你要计算的函数1：max;2:add"); scanf_s("%d",&status);

通过函数的指针参数可以间接的实现形参修改实参的值形参传递不能修改实参的值#include<stdio.h>void test(int n){ n++;}int main(void){ // 经常用指针访问数组 int i = 100; test(i); printf("i = %d
",i); system("pause"); return 0;}而使用指针进行传递就不会出现这种情况了，就可以进行实参的修改#include<stdio.h>.

这两句是等效的int main(void){ int buf[2][3] = { {1,2,3},{4,5,6} }; //int*p[3]；指针数组 int(*p)[3];//定义了一个指针，指向int [3]这种数据类型，指向二位数组的指针 p = buf;//p指向了二维数组中的第一行 p++;//指向了第二行 printf("%d
",sizeof(p)); printf("%d,%d
",p,p+1); //位移了1 * sizeof(int [3]) system.

#include<stdio.h>#include<string.h>int main(void){ int *a[10];//定义了一个指针数组，一共有10个成员，其中每一个成员都是int *类型 printf("%d,%d
", sizeof(a),sizeof(a[0])); double *b[10];//定义了一个指针数组，一共有10个成员，其中每一个成员都是double *类型 printf("%d,%d
", sizeof(b), sizeof

主要是将汉字字符进行逆序输出与英文不同的是，一个汉字占有两个字符。所以处理的时候需要注意思路其实就是讲最后的一个地址给第一个，倒数第二个给第二个，以此类推。#include<stdio.h>#include<string.h>int max_res(int *s){ char str[100] = "我是一个好孩子"; short *str_start = &str[0]; short *str_end = &str[strlen(str) -.

可以看到p/p1与p2相差为4#include<stdio.h>int main(void){ int buf[10]; int *p = buf; int *p1 = &buf[0]; int *p2 = &buf[1]; printf("%d,%d,%d
",p,p1,p2); //可以看到p/p1与p2相差为4 system("pause"); return 0;}#include<stdio.h>int main(void)

#include<stdio.h>int main(void){ char s1[100] = "hello"; char s2[100] = "world"; char *p1; p1 = s1; int len = 0; while (*p1) { p1++; //注意这一个一定需要，因为指针开始指向首地址，所以所对应的不为0，如果指针不移动 //while永远为真 len++; } printf("len=%d
",len); /.

首先需要安装mysql数据库使用命令:sudo apt-get install mysql-server但是我的在安装的时候没有进行秘密设置，最后不知道是什么鬼，也进不去。网上看了好多教程，有的说让我重新配置文件，但是也不好使，因为我找不到配置文件mysqld，所以有一种想重装Ubuntu的想法。还好想到可以卸载mysql重新设置，于是使用命令sudo apt-get remove mysql-*这样以来就把mysql卸载了然后使用这个命令进行清理dpkg -l |grep ^rc|awk

另一个程序已锁定文件的一部分，进程无法访问 打不开磁盘“D:\ubuntu\Ubuntu 64 位.vmdk”或它所依赖的某个快照磁盘。 模块“Disk”启动失败。 未能启动虚拟机添加链接描述

#include<stdio.h>#include<time.h>// rand是伪随机数产生器，每次调用rand产生随机数都是一样的// 如果调用的是随机数// 只要保证每次调用的是不同的void main(void){ time_t tm = time(NULL); srand(tm); int i = 0; for(i = 0; i < 10; i++) { int value = rand(); //产生随机数 printf("%d

#include<stdio.h>void main(void){ char s[100] = { " hello C++ " }; printf("(%s)
",s); int len = 0; while (s[len++]); len--; printf("%d
",len); for (int i = len-1; i >= 0; i--) { if (s[i] != ' ') { s[i + 1] = 0;

#include<stdio.h>typedef int ABC;// 全局结构体使用struct book{ char num[100]; char title[100]; char author[100];};typedef struct book zhx;void main(void){ zhx books[10]; strcpy(books[0].num, "第1本"); strcpy(books[0].title, "人性的弱点"); strcp

深度

帧差法由于场景中的目标在运动 ，目标的影像在不同图像 帧中的位置不同。该算法对时间上连续的两帧图像进行查分运算，不同帧对应的像素点相减，判断灰度差的绝对值，当绝对值超过一定阈值时，即可判断为运动目标，从而实现木匾的检测功能。帧间法非常简单，但是会引入噪音和空洞问题。混合高斯模型import numpy as npimport cv2# 经典测试视频cap = cv2.VideoCapture("test.MP4")# 形态学操作需要使用kernel = cv2.getStruct

module ‘cv2.cv2’ has no attribute ‘xfeatures2d’（问题已解决，亲测有效！）

import cv2import numpy as npimport matplotlib.pyplot as pltimg = cv2.imread("lena.jpg",0) # 后面的0可以使得其编程灰度图，不写的话就是彩色img = cv2.medianBlur(img,5)# opencv官方要求使用float32img_float32 = np.float32(img)dft = cv2.dft(img_float32,flags=cv2.DFT_COMPLEX_OUTPU

import cv2import numpy as npimport matplotlib.pyplot as pltlena = cv2.imread("car.jpg")# lena = cv2.cvtColor(lena,cv2.COLOR_BGR2GRAY)lena = cv2.medianBlur(lena,5)hist = cv2.calcHist([lena],[0],None,[256],[0,256]) # 传入图像，通道（0代表灰度）None掩膜图像，数目和像素范围..

高斯金字塔向下采样，金字塔的底部到顶部向上采样，金字塔的顶部底部扩充完，用0填充。import cv2import numpy as nplena = cv2.imread("zhx.jpg")# lena = cv2.cvtColor(lena,cv2.COLOR_BGR2GRAY)# lena = cv2.medianBlur(lena,5)def cv_show(name,img): cv2.imshow(name,img) cv2.waitKey(0)

Canny边缘检测1）使用高斯滤波器，以平滑图像，滤除噪声2）计算图像汇总每个像素点的梯度和方向3）应用非极大值（Non-Maximum Suppression）抑制，以消除边缘检测带来的杂散相应4）应用双阈值（Double-Threshold）检测来确定真实的和潜在的边缘5）通过抑制孤立的若边缘最终完成边缘检测双阈值import cv2import numpy as nplena = cv2.imread("lena.jpg")lena = cv2.cvtColor(lena,c

一般来讲，只有色彩变化较大的地方才会产生，也就是说，只有在边缘。图像sobel算子这个是水平方向的梯度，右边减去左边同样，下边减去上边。是竖直方向原始图像现在采用sobel算子，水平方向右边减去左边。如下所示：可以看到只有左边的，因为我们采用的是右边减去左边，其中中间的为白色，减去左边的黑丝就是 >0,因此会保留，而右边减去左边，是黑色减去中间，就成了黑丝减去白色<0所以会不显示。也就是只有一半如果想把右边的一半也显示，怎么办了？当然可以考虑将负数编程整数麻，试试

以下要讲解腐蚀核膨胀，从上面你应该可以看出来这在干啥了。1 腐蚀import cv2import numpy as npimg = cv2.imread('zhx.jpg')cv2.imshow('img',img)kernel = np.ones((3,3),np.uint8)erosion1 = cv2.erode(img,kernel,iterations=1)erosion2 = cv2.erode(img,kernel,iterations=2)erosion3 =.

首先加载一张照片import cv2 # BGRimport matplotlib.pyplot as pltimport numpy as npdef cv_show(name,img): cv2.imshow(name,img) cv2.waitKey(0) cv2.destroyAllWindows()img = cv2.imread('lena.jpg')cv_show('lena',img)显然可知，图像上存在大量的椒盐噪声均值滤波# 均值滤波

数据读取-图像cv2.imread_color彩色图形CV.imread_grayscale灰度图像import cv2 # BGRimport matplotlib.pyplot as pltimport numpy as np%matplotlib inlineimg = cv2.imread("zhx.jpg")cv2.imshow('zhx',img)cv2.waitKey(0)# cv2.waitKey(0)cv2.destroyAllWindows()由于每一次都要写

手写体作为深度学习的“Hello world”，几乎所有的课程都会讲到这个，今天带着大家一些看看吧。如果对你有所帮助，点个赞给个小关注，以后一起交流学习。前言首先和大家讲讲我为啥会看到这个，因为我需要写论文，关于图像增强的，比如夜视，曝光，去雨，去雪，去雾等，以往采用的是传统的方法“直方图，暗通道，retinex”等，现在随着深度学习的发展，只从12年人机大战，深度学习迅速爆棚，由于结果惊艳，所以深度学习进入了人们感兴趣的领域。好不夸张的说，现在各行各业都在使用深度学习，这个也是我需要研究的课题。

# '''# 注意这个问题：# 1 首先定义一个全局变量num# 2 然后定义了一个子函数myfun()，进行输出print(num)# 3 由于在子函数中，有重新定义了一个局部变量num,因此在子函数中的num不会使用全局函数中的，反而会使用局部中的， 但是局部中的申明在下方，因此会报错# ''’num = 42def myfun(): print(num) num = 100myfun()好好揣摩一下这个问题，你就知道咋回事了。...

多卷积核的使用不同方式结束后，图像尺寸长宽一样可以通过卷积或者padding1 X 1 卷积作用？单、多通道信息融合信息融合，不用别的信息做运算，仅仅对自身做运算。

对于batch 1 28 28 的图像用10个5 * 5核进行卷积，得到batch 10 （28 - 4） * （28 - 4) 即》（batch 10 24 * 24）经过一个2 * 2 最大池化，得到（batch 10 12 * 12）然后又经过20个5 * 5卷积核 输出（batch 20 8 * 8）经过一个2 * 2 最大池化，得到（batch 20 4 * 4）最后将其展开,输送到全连接层 20 * 4 * 4 = 320import torchfrom torchvisi.

全连接的使用，使得图像原有的位置发生改变，而卷积神经网络，是连续在一起的。栅格图像CCD做卷积通道数会改变卷积运算过程数乘单通道多通道共享权重# 测试import torchin_channels,out_channels = 5,10width,height = 100,100kernel_size = 3batch_size = 1input = torch.randn(batch_size, in

ont-hot 独热编码使用e^z为了保证大于0损失为0，对于分类是没有意义的练习import torchcriterion = torch.nn.CrossEntropyLoss()Y = torch.LongTensor([2,0,1])Y_pred1 = torch.tensor([[0.1,0.2,0.9], [1.1,0.1,0.2], [0.2,2.1,0.1]])Y_...

Batch-Size所有样本都参与训练称为一个epoch每次训练用的样本数量叫做batch-size迭代数据及进行打乱（shuffle）Dataset是一个抽象类，是不能直接实例化的而DataLoader是可以直接实例化的用到的loader函数，需要改写成，在0.4版本下会出现这样的问题还是4步，准备数据集，设计模型，建立模型和优化，训练例如minist数据集import torchfrom torch.utils.data import Datasetfrom

可以进行降维也可以进行升维，其实就是矩阵的计算。升维会出现一个问题，就是超参数的查找和应用。隐层越多，学习能力越强，单数学习能力太强也不是很好，会把模型里面的噪音也学习进来。（比如：学习能力太强了，就类似于把书本背死了）数据集可以在自行下载：链接: https://pan.baidu.com/s/1Ku5c99yDHNFMt8EJAcF5LA 提取码: n4xh如果失效了可以私信我torch.sigmoid、torch.nn.Sigmoid和torch.nn.funct...

逻辑回归，做分类问题minist dataset线性回归得到的是具体的值，而逻辑回归得到的是概率。如果只有两个类别，得到的就是二分类。sigmoid代码运行有问题，不知道问题出在哪里，感兴趣的小伙伴可以试试看import torchimport numpy as npimport matplotlib.pyplot as pltimport torch.nn.functional as F# 1 数据准备，使用torch。tensor进行x_data = torc

import torchimport torch.nn.functional as Ffrom torch.autograd import Variableimport matplotlib.pyplot as plt# fake datax = torch.linspace(-5, 5, 200) # 使用torch生成500个等差数据x = Variable(x)x_np = x.data.numpy() # 转换成 np 类型y_relu = F.relu(x).data..

基础网络模型搭建代码import torchimport numpy as npimport matplotlib.pyplot as plt# 1 数据准备，使用torch。tensor进行x_data = torch.tensor([[1.0],[2.0],[3.0]])y_data = torch.tensor([[2.0],[4.0],[6.0]])# 2 解释：定义一个类，继承Module，然后进行初始化操作class LinearModel(torch.nn.Module):