问题1：扔下圆球的位置（feature特征变量）变化，最终掉落奖项（label结果标签）的变化

  • feature ----输入
  • f(x) ----模型，算法
  • label ----输出

　　大量已知的数据，训练得出f(x)

  • 一般的三步

    • 收集数据feature,label
    • 选择数据模型建立feature,label的关系--f(x)
    • 根据选择的模型进行预测　
  • 人类建立模型：多次尝试增加经验提高预测到达公司的时间
  • 机器学习：利用统计学，概率论，信息论的数学方法，利用已知的数据，创建一种模型，利用这种模型进行预测（高考与之类似）
    • 机器学习经典模型：KNN模型（人以类聚，物以群分）

      • 基本步骤　　

        • 1.采集数据
        • 2.计算实验数据与预测位置的距离
        • 3.按照距离从小到大排序
        • 4.选取最顶部的K条记录，得到最大概率的落点
        • 5.预测预测位置的落点
      • python实现 
        • import numpy as np
          
import collections as c
          
# 1.采集数据
          
data = np.array([
          
	[154, 1],
          
	[126, 2],
          
	[70, 2],
          
	[196, 2],
          
	[161, 2],
          
	[371, 4],
          
])

# feature,label
          
feature = data[:, 0]
          
label = data[:, -1]

# 2.计算实验数据与预测点的距离
          
predictPoint = 200
          
distance = list(map(lambda x: abs(x - predictPoint), feature))

# 3.按照距离从小到大排序,排序下标
          
sortindex = np.argsort(distance)

# 4.选取最顶部的K条记录，得到最大概率的落点,假设K=3
          
sortedlabel = label[sortindex]
          
k = 3
          
# 预测结果[(结果，次数)]
          
# 5.预测预测位置的落点
          
predictlabel = c.Counter(sortedlabel[0:k]).most_common(1)[0][0]

print(predictlabel)
      • 代码封装 
        • import numpy as np
          
import collections as c

# 代码封装

def knn(k, predictPoint, feature, label):
          
	distance = list(map(lambda x: abs(x - predictPoint), feature))
          
	sortindex = np.argsort(distance)
          
	sortedlabel = label[sortindex]
          
	predictlabel = c.Counter(sortedlabel[0:k]).most_common(1)[0][0]
          
	return predictlabel

if __name__ == '__main__':
          
	data = np.array([
          
		[154, 1],
          
		[126, 2],
          
		[70, 2],
          
		[196, 2],
          
		[161, 2],
          
		[371, 4],
          
	])
          
	# feature,label
          
	feature = data[:, 0]
          
	label = data[:, -1]
          
	k = 3
          
	predictPoint = 200
          
	res = knn(k, predictPoint, feature, label)
          
	print(res)
      • 实际数据验证
        • 数据集https://pan.baidu.com/s/1rw5aFlVzZb6SBdY09Rckhg
        • import numpy as np
          
import collections as c

# 代码封装

def knn(k, predictPoint, feature, label):
          
	distance = list(map(lambda x: abs(x - predictPoint), feature))
          
	sortindex = np.argsort(distance)
          
	sortedlabel = label[sortindex]
          
	predictlabel = c.Counter(sortedlabel[0:k]).most_common(1)[0][0]
          
	return predictlabel

if __name__ == '__main__':
          
	data = np.loadtxt("数据集/data0.csv", delimiter=",")
          
	# feature,label
          
	feature = data[:, 0]
          
	label = data[:, -1]
          
	k = 3
          
	predictPoint = 300
          
	res = knn(k, predictPoint, feature, label)
          
	print(res)

        训练集和测试集

        • 打散数据得到训练集和测试集
        • import numpy as np
        • import collections as c

# 代码封装

def knn(k, predictPoint, feature, label):
          
	distance = list(map(lambda x: abs(x - predictPoint), feature))
          
	sortindex = np.argsort(distance)
          
	sortedlabel = label[sortindex]
          
	predictlabel = c.Counter(sortedlabel[0:k]).most_common(1)[0][0]
          
	return predictlabel

if __name__ == '__main__':
          
	data = np.loadtxt("数据集/data0.csv", delimiter=",")
          
	# 打散数据
          
	np.random.shuffle(data)
          
	# 训练90%
          
	traindata = data[100:-1]
          
	# 测试10%
          
	testdata = data[0:100]
          
	# 保存训练数据,测试数据
          
	np.savetxt("data0-test.csv", testdata, delimiter=",", fmt="%d")
          
	np.savetxt("data0-train.csv", traindata, delimiter=",", fmt="%d")

	traindata = np.loadtxt("data0-train.csv", delimiter=",")

	# feature,label
          
	feature = traindata[:, 0]
          
	label = traindata[:, -1]
          
	max_accuracy = 0
          
	max_k = []
          
	# 预测点，来自测试数据的每一条记录
          
	testdata = np.loadtxt("data0-test.csv", delimiter=",")
          
	for k in range(1,100):
          
		count = 0
          
		for item in testdata:
          
			predict = knn(k, item[0], feature, label)
          
			real = item[1]
          
			if predict == real:
          
				count += 1

		accuracy = count * 100.0 / len(testdata)
          
		if accuracy >= max_accuracy:
          
			max_accuracy = accuracy
          
			max_k.append(k)
          
		print("k = {},准确率：{}%".format(k,count*100.0/len(testdata)))
          
	print(set(max_k))　

      • 多维数据的距离的选取

        • 欧式距离即可

      • 预测不是很准确
        • 1.模型的参数选择不够好，调参---调参工程师

          • K选择太小，噪音干扰太明显
          • K选择太大，其他类型的会涵盖　
          • K值的评价标准
            • 训练集trainData---得到模型
            • 测试集testData---验证模型　
          • 经验：K一般选取样本集开平方　　　　
        • 2.影响因子不够多
          • 增加数据的维度

            • 球的颜色导致弹性不同
            • 特殊数据的导入 
              • import numpy as np

def colornum(str):
                
	dict = {"红":0.50,"黄":0.51,"蓝":0.52,"绿":0.53,"紫":0.54,"粉":0.55}
                
	return dict[str]

data = np.loadtxt('数据集/data1.csv',delimiter=",",converters={1:colornum},encoding="gbk")
                
print(data)
        • 3.样本数据量不够
        • 4.选择的模型不够好，选择其他机器学习的模型　　　
    • 线性回归　　
      • 是一种总结规律，总结模型的解决方法。不需要全数据集
      • 损失函数：评测算法的好坏
      • 最小均方差　
      • 最小均方差越接近0越好
      • 步骤
        • 1.随机选取m和b
        • 2.分别计算m和b的偏导数
        • 3.如果m和b的偏导都很小，就成功
        • 4.根据学习速率，计算出修改的值
        • 5.b和m分别减去要修改的值　　
      • python实import numpy as np
      • # data = np.array([
        
# 	[80, 200],
        
# 	[95, 230],
        
# 	[104, 245],
        
# 	[112, 274],
        
# 	[125, 259],
        
# 	[135, 262],
        
# ])

data = np.loadtxt('数据集/cars.csv', delimiter=",", skiprows=1, usecols=(4, 1))

m = 1
        
b = 1

xarray = data[:, 0]
        
yreal = data[:, -1]
        
learningrate = 0.00001

# 梯度下降
        
def grandentdecent():
        
	# 求斜率
        
	bslop = 0
        
	for index, x in enumerate(xarray):
        
		bslop = bslop + m * x + b - yreal[index]
        
	bslop = bslop * 2 / len(xarray)
        
	# print("对b求导的斜率={}".format(bslop))

	mslop = 0
        
	for index, x in enumerate(xarray):
        
		mslop = mslop + (m * x + b - yreal[index]) * x
        
	mslop = mslop * 2 / len(xarray)
        
	# print("对m求导的斜率={}".format(mslop))

	return (bslop, mslop)

def train():
        
	for i in range(1, 10000000):
        
		bslop, mslop = grandentdecent()
        
		global m
        
		m = m - mslop * learningrate
        
		global b
        
		b = b - bslop * learningrate
        
		if (abs(mslop) < 0.5 and abs(bslop) < 0.5):
        
			break

	print("m={},b={}".format(m, b))

if __name__ == '__main__':
        
	train()

	# 用训练集得到公式
        
	# 用测试集验证正确率
      • import numpy as np

# 面积，房价
        
data = np.array([
        
	[80, 200],
        
	[95, 230],
        
	[104, 245],
        
	[112, 274],
        
	[125, 259],
        
	[135, 262],
        
])
        
# 1.feature,label,axis=1保留原始维度
        
feature = np.expand_dims(data[:, 0], axis=1)
        
# feature = data[:,0:1]
        
label = np.expand_dims(data[:, -1], axis=1)

# 2.weight
        
m = 1
        
b = 1

weight = np.array([
        
	[m],
        
	[b],
        
])
        
# 3.feature*weight,需要在feature后面补一列1---每一行代表mx+b
        
feature = np.append(feature, np.ones(shape=(6, 1)), axis=1)

print(feature)
        
# 4.feature*weight - label  得到差值difference
        
difference = np.dot(feature, weight) - label
        
# 5.feature^T*difference/n 先将feature转置在乘，得到对B和M的偏导bslop,mslop
        
bmslop = np.dot(feature.T, difference)
        
bmslop = bmslop*2/len(feature)
        
# 6.仅需使其数字接近0即可　　　　　　　　 

    • 图形变化

      • import matplotlib.pyplot as plt
        
import numpy as np
        
import math

points = np.array([
        
	[0, 0],
        
	[0, 5],
        
	[3, 5],
        
	[3, 4],
        
	[1, 4],
        
	[1, 3],
        
	[2, 3],
        
	[2, 2],
        
	[1, 2],
        
	[1, 0],
        
	[0, 0],
        
])
        
plt.plot(points[:, 0], points[:, 1])
        
for i in range(1,13):
        
	# # 1.平移
        
	# matrix = np.array([0.5*i, 0])
        
	# newpoints = points + matrix
        
	# 2.旋转
        
	# matrix = np.array([
        
	# 	[math.cos(math.pi/6),-math.sin(math.pi/6)],
        
	# 	[math.sin(math.pi/6),math.cos(math.pi/6)],
        
	# ])
        
	# points = np.dot(points,matrix)
        
	# 3.缩放
        
	matrix = np.array([
        
		[1.05,0],
        
		[0,1.05],
        
	])
        
	points = np.dot(points, matrix)
        
	plt.plot(points[:, 0], points[:, 1])
        
	plt.xlim(-10,10)
        
	plt.ylim(-10,10)
        
	plt.show()　　

    • 逻辑回归

      • 将线性回归置于e的指数即可

      • e的求法

        • import math

n = 1000000

e = math.pow((1+1.0/n),n)

print(e)

      • 激活函数，sigmoid　

        • 逻辑回归实现梯度下降

          • import numpy as np

data = np.array([
            
	[5, 0],
            
	[15, 0],
            
	[25, 1],
            
	[35, 1],
            
	[45, 1],
            
	[55, 1],
            
])

# 1.feature,label,axis=1保留原始维度
            
feature = np.expand_dims(data[:, 0], axis=1)
            
# feature = data[:,0:1]
            
label = np.expand_dims(data[:, -1], axis=1)

learingrate = 0.00001
            
m = 1
            
b = 1

weight = np.array([
            
	[m],
            
	[b],
            
])

feature = np.append(feature, np.ones(shape=(6, 1)), axis=1)

def gradentDecent():
            
	predict = 1 / (1 + np.exp(-np.dot(feature, weight)))
            
	difference = predict - label
            
	bmslop = np.dot(feature.T, difference)
            
	bmslop = bmslop / len(feature)
            
	return bmslop

def train():
            
	for i in range(1, 10):
            
		slop = gradentDecent()
            
		global weight
            
		weight = weight - learingrate * slop
            
		print(slop)

if __name__ == '__main__':
            
	train()

    • 神经网络：主要用于分类和聚类

      • 用一条线划分两种类型的属性---分割线计算

      • 高维空间，只是变成了矩阵相乘---用面分割

      • 神经元=激活函数=f(x)

      • 手工拟合OR，AND，XOR

      • 感知机：梯度下降实现

        • 随便划线，感知点的情绪（- -），向着开心的方向进行移动

        • 调整线的斜率，使结果更好　　

        • 梯度下降：连续可导，可以求斜率

        • MSE最小均方差

        • Cross-entropy交叉熵

          • p(red)=p(blue)

          • sigmoid函数处理线性函数，　　　　

  • 聚类算法

    • 相似的事务归为一类-标签化---物以类聚

    • k-means

      • k:中心点的个数，质心

      • means：求平均

      • 不断迭代，更新质心　

      • 步骤

        • 1.选择聚类的个数K

        • 2.生成K个聚类中心点

        • 3.计算所有样本点到聚类中心点的距离

        • 4.更新质心(求聚类后的x,y平均值)，迭代聚类

        • 5.重复4直到满足收敛要求

        • import numpy as np
          
import matplotlib.pyplot as plt
          
from sklearn.cluster import MiniBatchKMeans, KMeans
          
# 测量
          
from sklearn import metrics
          
# 球状簇
          
from sklearn.datasets.samples_generator import make_blobs

# 生成数据集，样本数=1000，特征数=2，中心=以哪些点为中心生成样本点,标准差=围绕中心的标准差，随机状态值=每次运行生成散点图一致
          
x, y = make_blobs(n_samples=1000, n_features=2, centers=([-1, -1], [0, 0], [1, 1], [2, 2]),
          
				  cluster_std=(0.4, 0.2, 0.2, 0.2), random_state=9)
          
# 生成散点图
          
plt.scatter(x[:, 0], x[:, 1], marker="o")
          
plt.show()

# 可视化
          
for index, k in enumerate((2, 3, 4, 5)):
          
	plt.subplot(2, 2, index + 1)
          
	# 随机选取200个点，分别用特征2,3,4,5作为特征值，进行K——means
          
	y_pred = MiniBatchKMeans(n_clusters=k, batch_size=200, random_state=9).fit_predict(x)
          
	# 聚类效果评分
          
	score = metrics.calinski_harabaz_score(x, y_pred)
          
	plt.scatter(x[:, 0], x[:, 1], c=y_pred)
          
	plt.text(.99,.01,
          
			 ('k=%d,score:%.2f' % (k, score)),
          
			 fontsize=10,
          
			 transform=plt.gca().transAxes,
          
			 horizontalalignment="right")
          
plt.show()

      • 　　　

      • 完整的预处理例子

        • '''
          
完整的机器学习流程
          
'''

# 1.导入库
          
import numpy as np
          
import pandas as pd
          
import matplotlib.pyplot as plt
          
import seaborn as sns
          
import numpy.random as nr
          
import math
          
from sklearn.cluster import MiniBatchKMeans, KMeans
          
# 测量
          
from sklearn import metrics
          
# 球状簇
          
from sklearn.datasets.samples_generator import make_blobs

# 2.观察数据集
          
# 路径带中文，前面先用open打开
          
auto_prices = pd.read_csv(open('工业汽车数据集应用实践/Automobile price data _Raw_.csv'))
          
# print(auto_prices.head(20))

# 3.数据的预处理，重新编码
          
auto_prices.columns = (str.replace('-', '_') for str in auto_prices.columns)

# 4.处理缺失值
          
# 找出所有缺失值
          
(auto_prices.astype(np.object) == '?').any()

for col in auto_prices.columns:
          
	if auto_prices[col].dtypes == object:
          
		count = 0
          
		count = [count + 1 for x in auto_prices[col] if x == '?']
          
		print(col + '	' + str(sum(count)))

# 处理缺失值
          
auto_prices.drop('normalized_losses', axis=1, inplace=True)
          
cols = ['price', 'bore', 'stroke', 'horsepower', 'peak_rpm']
          
for column in cols:
          
	auto_prices.loc[auto_prices[column] == '?', column] = np.nan
          
auto_prices.dropna(axis=0, inplace=True)
          
print(auto_prices.shape)

# 5.转换列数据类型
          
for column in cols:
          
	auto_prices[column] = pd.to_numeric(auto_prices[column])
          
print(auto_prices[cols].dtypes)

# 6.特征工程
          
# 汇总变量类别，转换ln,交互的变量合并
          
# 聚合特征变量
          
print(auto_prices['num_of_cylinders'].value_counts())
          
# print(auto_prices.columns)

cylinder_categories = {
          
	'three': 'three_four',
          
	'four': 'three_four',
          
	'five': 'five_six',
          
	'six': 'five_six',
          
	'eight': 'eight_twelve',
          
	'twelve': 'eight_twelve', }
          
auto_prices['num_of_cylinders'] = [cylinder_categories[x] for x in auto_prices['num_of_cylinders']]
          
print(auto_prices['num_of_cylinders'].value_counts())

# 7.箱型图
          
# 哪个特征影响价格走向
          
def plot_box(auto_price, col, col_y='price'):
          
	sns.set_style('whitegrid')
          
	sns.boxplot(col, col_y, data=auto_price)
          
	plt.xlabel(col)
          
	plt.ylabel(col_y)
          
	plt.show()

plot_box(auto_prices, 'num_of_cylinders')

print(auto_prices['body_style'].value_counts())
          
body_cats = {
          
	'sedan': 'sedan',
          
	'hatchback': 'hatchback',
          
	'wagon': 'wagon',
          
	'hardtop': 'hardtop_convert',
          
	'convertible': 'hardtop_convert', }
          
auto_prices['body_style'] = [body_cats[x] for x in auto_prices['body_style']]
          
print(auto_prices['body_style'].value_counts())

# 8.特征图
          
# 哪个特征有别于其他特征
          
def plot_box(auto_price, col, col_y='price'):
          
	sns.set_style('whitegrid')
          
	sns.boxplot(col, col_y, data=auto_price)
          
	plt.xlabel(col)
          
	plt.ylabel(col_y)
          
	plt.show()

plot_box(auto_prices, 'body_style')

# 9.转换变量
          
def hist_plot(vals, lab):
          
	sns.distplot(vals)
          
	plt.title('Histogram of' + lab)
          
	plt.xlabel('value')
          
	plt.ylabel('Density')
          
	plt.show()

hist_plot(auto_prices['price'], 'prices')
          
# 对数转换
          
auto_prices['log_price'] = np.log(auto_prices['price'])
          
hist_plot(auto_prices['log_price'], 'log_price')

# 10.可视化
          
# 看价格与其他特征是否存在线性或非线性的关系
          
def plot_scatter_shape(auto_prices, cols, shape_col='fuel_type', col_y='log_price', alpha=0.2):
          
	shapes = ['+', 'o', 's', 'x', '^']
          
	unique_cats = auto_prices[shape_col].unique()
          
	for col in cols:
          
		sns.set_style('whitegrid')
          
		for i, cat in enumerate(unique_cats):
          
			temp = auto_prices[auto_prices[shape_col] == cat]
          
			sns.regplot(col, col_y, data=temp, marker=shapes[i], label=cat,
          
						scatter_kws={'alpha': alpha}, fit_reg=False, color='blue')

		plt.title('scatter plot of' + col_y + 'vs.' + col)
          
		plt.xlabel(col)
          
		plt.ylabel(col_y)
          
		plt.legend()
          
		plt.show()

num_cols = ['curb_weight', 'engine_size', 'horsepower', 'city_mpg']
          
plot_scatter_shape(auto_prices, num_cols)

    • 算法效果的衡量标准

      • SSE（Sum of Squear due to Error）误差平方和

        • 每个点跟质心的距离　　

      • K值确定：Elbow method 肘方法

        • SSE跟聚类个数画图
        • 找出拐点来确定聚类数　　
        • 　　　　　　　　
      • 轮廓系数法（Silhouette Coefficient）
        • 根据轮廓边缘的变化感知聚类的凝聚度和分离度
        • 　　

      • CH（Calinski-Harabasz）

        • 数据类别距离平方和越小越好，类别之间平方和越大越好

        • 　　　　　　　　　　　　　　　　　　

          　　　　　　

　　

<人工智能>人工智能基础的更多相关文章

  1. 饮冰三年-人工智能-Python-17Python基础之模块与包

    一.模块(modue) 简单理解一个.py文件就称之为一个模块. 1.1 模块种类: python标准库 第三方模板 应用程序自定义模块(尽量不要与内置函数重名) 1.2 模块导入方法 # impor ...

  2. [人工智能]NumPy基础

    理解NumPy 本文主要介绍NumPy的基础知识,NumPy是一个功能强大的Python库,允许更高级的数据操作和数学计算. 什么是NumPy NumPy,来源自两个单词:Numerical和Pyth ...

  3. [人工智能]Pytorch基础

    PyTorch基础 摘抄自<深度学习之Pytorch>. Tensor(张量) PyTorch里面处理的最基本的操作对象就是Tensor,表示的是一个多维矩阵,比如零维矩阵就是一个点,一维 ...

  4. 饮冰三年-人工智能-Python-16Python基础之迭代器、生成器、装饰器

    一:迭代器: 最大的特点:节省内存 1.1 迭代器协议 a:对象必须提供一个next方法, b:执行方法要么返回迭代中的下一项,要么抛弃一个Stopiteration异常, c:只能向后不能向前. 1 ...

  5. 饮冰三年-人工智能-Python-15Python基础之文件处理

    # 写文件--开始 f=open('test','w',encoding="utf-8") #如果有则写,没有就创建 print(f.writable()) #True f.wri ...

  6. 饮冰三年-人工智能-Python-14Python基础之变量与函数

    1:函数:函数是逻辑结构化和过程化的一种编程方法.函数即变量 #参数组:**字典 *列表 def test(x,*args): print(args); print(args[0]); print(& ...

  7. 饮冰三年-人工智能-Python-13Python基础之运算符与数据类型

    1:算数运算符 + - * / ** % // 2: 成员运算符 in not in name = """张三""" if "张& ...

  8. 身边的人工智能&人工智能发展史

    智能家具 扫地机器人 智能音箱 个人助手 在线翻译 谷歌翻译 微软翻译 YouTube 视频翻译 图像识别 人脸识别 AI+摄像头 下棋高手 Alphago 2017年打败柯洁 成为世界第一 Alph ...

  9. 零基础自学人工智能，看这些资料就够了（300G资料免费送）

    为什么有今天这篇? 首先,标题不要太相信,哈哈哈. 本公众号之前已经就人工智能学习的路径.学习方法.经典学习视频等做过完整说明.但是鉴于每个人的基础不同,可能需要额外的学习资料进行辅助.特此,向大家免 ...

随机推荐

  1. 洛谷 P2024 [NOI2001]食物链——带权值的并查集维护

    先上一波题目 https://www.luogu.org/problem/P2024 通过这道题复习了一波并查集,学习了一波带权值操作 首先我们观察到 所有的环都是以A->B->C-> ...

  2. js中继承的实现，原型链的知识点归纳，借用构造函数，组合继承（伪经典继承）

    博客搬迁,给你带来的不便,敬请谅解! http://www.suanliutudousi.com/2017/10/31/js%e4%b8%ad%e7%bb%a7%e6%89%bf%e7%9a%84%e ...

  3. JPA接口整理归纳方法规则

    Keyword Sample JPQL snippet And findByLastnameAndFirstname … where x.lastname = ?1 and x.firstname = ...

  4. Neo4J(Cypher语句)初识

    欢迎各路大神临幸寒舍 以下节点标签为people,friend,用户自己也可以设置成其他标签,查询时需要用到标签.这个标签可以类比为关系数据库中的表名 创建节点.关系 创建节点(小明):create ...

  5. expect的模式

    expect的模式其实就是对话模式: expect    # 期望什么 send      # 我给你什么 比如: expect "password: "    # 碰到什么了 s ...

  6. .net Mvc Dapper 方法封装

    首先需要添加 NuGet 包 Dapper 以及引用Configuration <connectionStrings>      <add name="SqlSrc&quo ...

  7. Gym 102028J 扫描线/二维差分 + 解方程

    题意:有一个二维平面,以及n个操作,每个操作会选择一个矩形,使得这个二维平面的一部分被覆盖.现在你可以取消其中的2个操作,问最少有多少块地方会被覆盖? 思路:官方题解简洁明了,就不细说了:https: ...

  8. PHP 的 new static 和 new self

    下面我们举个例子: class Father { public static function getSelf() { return new self(); } public static funct ...

  9. Java高并发网络编程(五)Netty应用

    推送系统 一.系统设计 二.拆包和粘包 粘包.拆包表现形式 现在假设客户端向服务端连续发送了两个数据包,用packet1和packet2来表示,那么服务端收到的数据可以分为三种,现列举如下: 第一种情 ...

  10. C++ STL(一)介绍及string

    STL: C++标准模板库的简称,它是C++的一部份.标准C++库的所有的标识符都是在一个名为std的命名空间中定义的 在使用STL中相关模板时,需要包含相关头文件,然后using namespace ...