#生成数据集
import numpy as np
n_dots=400
X=5*np.random.rand(n_dots,1)
y=np.cos(X).ravel()#将多为数组将为一维
#print(X)
print("******************")
#print(y)

#添加一些噪声
y=y+0.2*np.random.rand(n_dots)-0.1

#训练模型
from sklearn.neighbors import KNeighborsRegressor
k=5
knn=KNeighborsRegressor(k)
knn.fit(X,y)

#将所有的预测点用吸纳画起来，形成回归曲线
T=np.linspace(0,5,500)[:,np.newaxis]#np.newaxis 在使用和功能上等价于 None，其实就是 None 的一个别名. 
print(T.shape)
y_pred=knn.predict(T)
print("得分为{0}".format(knn.score(X,y)))

#画出拟合曲线
from matplotlib import pyplot as plt
plt.figure(figsize=(16,10),dpi=144)
plt.scatter(X,y,c='g',label='data',s=100)#画出训练样本
plt.plot(T,y_pred,c='k',label='prediction',lw=4)#画出拟合曲线（T为横坐标，y_pred为纵坐标
plt.axis('tight')
plt.title("KNeightborsRessor")
plt.show()

![gg](C:\Users\wuxun\Desktop\gg.PNG)from sklearn import datasets
import numpy as np
from sklearn.model_selection import train_test_split

text=datasets.load_iris()
#print(text)
target=text.target
data=text.data
#print(target)
print("***********")
#print(data)

data.shape
#将样本分为训练集和测试集
X_train,X_test,Y_train,Y_test=train_test_split(data,target,test_size=0.2)

#通过使用普通的k-均值算法，带权重的k-均值算法，指定半斤的k-均值算法对数据进行拟合
from sklearn.neighbors import KNeighborsClassifier,RadiusNeighborsClassifier

#构造三个模型

models=[]
models.append(("KNN",KNeighborsClassifier(n_neighbors=2)))
models.append(("KNN with weight",KNeighborsClassifier(n_neighbors2,weightsh="distance")))
models.append(("Radius Neighbors",RadiusNeighborsClassifier(n_neighbors=2,radius=500.0)))

#分别训练三个模型
results=[]
for name,model in models:
    model.fit(X_train,Y_train)
    results.append((name,model.score(X_test,Y_test)))
for i in range(len(results)):
    print("name: {}: score:{}".format(results[i][0],results[i][1]))

#由于随机测验数据存在的差异，所以我们用KFold计算一般的算法性质
from sklearn.model_selection import KFold
from sklearn.model_selection import cross_val_score
results=[]
for name,model in models:
    kfold=KFold(n_splits=10)#将数据集分成十份，一份作为验证集
    cv_result=cross_val_score(model,data,target,cv=kfold)#函数计算出十次数据集组合而得的模型得分
for i in range(len(results)):
    print("name {} :scor {}".format(results[i][0],results[i][1].mean()))
    
#模型训练及分析
#普通的knn训练模型可能更优，我们使用普通的knn模型训练数据

knn=KNeighborsClassifier(n_neighbors=2)
knn.fit(X_train,Y_train)
train_score=knn.score(X_train,Y_train)
test_score=knn.score(X_test,Y_test)
print("tsin score:{},test score:{}".format(train_score,test_score))

from sklearn.model_selection import ShuffleSplit
#from common.utils import plot_learning_curve

#knn.KNeighborsClassifier(n_neighbors=2)
#cv=ShuffleSplit(n_splits=10,test_size=0.2,random_state=0)

from sklearn.feature_selection import SelectKBest#选择相关性最大的两个特征

selector=SelectKBest(k=2)
X_new=selector.fit_transform(data,target)
X_new[0:5]

#选择最好的两个特征在对三个模型进行检测
results=[]
for name,model in models:
    kfold=KFold(n_splits=10)
    cv_result=cross_val_score(model,X_new,target,cv=kfold)
    results.append((name,cv_result))
for i in range(len(results)):
    print("name:{}; cross val score:{}".format(results[i][0],results[i][1].mean()))
    
    
#画出二维数据
from matplotlib import pyplot as plt
plt.figure(figsize=(10,6),dpi=200)
plt.ylabel("BMI")
plt.xlabel("Glucose")
plt.scatter(X_new[:,0],X_new[:,1],c=target)
#plt.scatter(X_new,target,c='r',s=20,marker='o')

pip install tornado==4.5.3

C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v9.0\

C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v9.0\lib\x64
C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v9.0

conda create --name tensorflow-gpu python=3.6.1

activate tensorflow-gpu

python

import tensorflow as tf

import tensorflow as tf
tf.enable_eager_execution()

a = tf.constant(1)
b = tf.constant(1)
c = tf.add(a, b)  

print(c)

import numpy as np
from collections import defaultdict
from operator import itemgetter

dataset_filename="C:\Python数据挖掘入门与实践代码和数据集\Code_REWRITE\Chapter 1"
X=np.loadtxt(dataset_filename+r"\affinity_dataset.txt")
#print(X)
v=defaultdict(int)
i=defaultdict(int)
n=defaultdict(int)

for sample in X:
    for permiss in range(4):
        if sample[permiss]==0:
            continue
        n[permiss]+=1
        for c in range(4):
            if permiss==c:
                continue
            if sample[c]==1:
                v[(permiss,c)]+=1#两者均为1时加一
            else:
                i[(permiss,c)]+=1#两者不同时为1

support=v
#permiss=1
#c=3
#print(" -Support:{0}".format(support[(permiss,c)]))
confidence=defaultdict(float)
'''
for permiss,c in v.keys():
    rule=(permiss,c)
    confidence[rule]=v[rule]/n[permiss]
    print(confidence[rule])
'''
def print_rule(permiss,c,support,confidence,features):
    permiss_name=features[permiss]
    c_name=features[c]
    print("Rule if a people buy {0} they will also buy {1}".format(permiss_name,c_name))

    #s输出置信度
    #输出支持度
    print("  -Support: {0}".format(support[(permiss,c)]))
    print("  -Confidence".format(confidence[(permiss,c)]))
##排序找出最佳规则

print(support)#内涵键值对
sorted_support=sorted(support.items(),key=itemgetter(1),reverse=True)
#输出支持度最高的五个规则
for index in range(5):
    print(" Rule #{0}".format(index+1))
    permiss,c=sorted_support[index][0]
    print_rule(permiss,c,support,confidence,features)
    
#输出置信度最高的规则
sorted_confidence=sorted(support.items(),key=itemgetter(1),reverse=True)
for index in sorted_confidence:
    permiss,c=sorted_confidence[index][0]
    print_rule(permiss,c,support,confidence,features)

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

//用户数据库
public class SqlServer {
   private static Map<String,UserInfor>SQL=new HashMap();
   
   //判断输入账号是否存在
    public static boolean CheckUser(String name) {
    	if(SQL.containsKey(name)) {
    		return true;
    	}
    	//System.out.println("不存在此用户："+name);
    	return false;
    }
    
    //检查账号密码是否输入正确
    public static boolean CheckPassword(String name,String Password) {
    	if(SQL.get(name).Check(Password)) {
    		return true;
    	}else {
    		return false;
    	}
    }
    
    //返回对象数组
    public static Map<String, UserInfor> Getusers() {
    	return SQL;
    }
    
    
    
    //返回key1值对应的对象
    public UserInfor returnUser(String name) {
    	return SQL.get(name);
    }
    
    
    
    
    //返回用户姓名列表
    public String[] Groupusername() {
    	
    	Object[] key =  SQL.keySet().toArray();    
    	Arrays.sort(key); 
    	int l=key.length;
    	String username[]=new String[l];
  
    	
    	for(int i=0;i<key.length;i++) {
    		username[i]=key[i].toString();
    		//System.out.println(key[i].toString());
    	}
    	
    	
        return username;
    }
    	
    //创建用户
    public int BuildNewUser(String name,String password) {
    	if(SQL.containsKey(name)) {
    		//System.out.println("该用户名已存在!请重新输入");
    		return 0;
    	   }else {
    		   UserInfor u=new UserInfor();
    		   u.SetName(name);
    		   u.SetPwd(password);
    		   System.out.println("新用户密码为："+password);
    		   this.SQL.put(name,u);
    		   return 1;
    	   }
    	
    }
    
    
    //遍历打印Map中的键值对
    public static void ShowMap(){
        for(Map.Entry<String, UserInfor> entry: SQL.entrySet()){
            System.out.println(entry.getKey()+"="+entry.getValue().toString());
        }
    }
    
    //删除用户
    public static void DeleteUser(String name) {
    	SQL.get(name).SetOnline2();
    
    	
    }
    
    //返回在线的用户id列表
    public String[] WhoisOnline() {
    	
    	Object[] key =  SQL.keySet().toArray();    
    	Arrays.sort(key); 
    	int l=key.length;
    	String username[]=new String[l];
    	for(int i=0;i<key.length;i++) {
            if(SQL.get(key[i].toString()).getOnline()) {//如果在线则加入数组
    		username[i]=key[i].toString();
           }
    	}
    	return username;
    }
    
    //返回不在线用户列表
    public String[] WHoisnotOnline() {
    	Object[] key =  SQL.keySet().toArray();    
    	Arrays.sort(key); 
    	int l=key.length;
    	String username[]=new String[l];
    	for(int i=0;i<key.length;i++) {
            if(!SQL.get(key[i].toString()).getOnline()) {//如果不在线则加入数组
    		username[i]=key[i].toString();
           }
    	}
    	return username;
    }
    
    //系统先建立十个用户
    static{
    	for (int i=0;i<10;i++) {
    		UserInfor u=new UserInfor();
    		u.SetName(String.valueOf(i+1));//用户名即是索引
    		u.SetPwd("123456");
    		SQL.put(u.get_name(),u);
    	}
    }
   
    
}

public class Client extends Thread{/部分代码
	
		//监听事件的添加
		send.addActionListener(new ActionListener() {//发送私聊消息

			@Override
			public void actionPerformed(ActionEvent arg0) {
				// TODO Auto-generated method stub
			   WriterMess("1");//表示是私聊信息
         	   WriterMess(selected);//私聊用户号
         	   String mess=textfield.getText();
         	   WriterMess(mess);//私聊信息
         	   area.append("自己："+mess+"\n");
         	  if(mess.equals("bye")) {//设置用户下线
					WriterMess("3");
				}
			}
			
		});
		
		send2.addActionListener(new ActionListener() {//实现群聊功能

			@Override
			public void actionPerformed(ActionEvent arg0) {
				// TODO Auto-generated method stub
				try {
					WriterMess("2");
					String gets=textfield2.getText();				
					WriterMess(gets);
					if(gets.equals("bye")) {//设置用户下线
						WriterMess("3");
					}
				} catch(Exception e) {
					e.printStackTrace();
					
				}
			}
			
		});
		
		 //JList点击事件的添加
		list1.addMouseListener(new MouseAdapter() {

			@Override
			public void mouseClicked(MouseEvent arg0) {
				// TODO Auto-generated method stub
				String select=(String) list1.getSelectedValue();
            	if(!select.equals(userinfor.get_name())) {//不能对自己进行私聊
                   area.append("	================================================\n");
            	   area.append("	===你选择"+select+"号在线客户进行私聊===\n");
            	   
            	   selected=select;

            	}else {
            		area.append("    	============您不能选择自己进行私聊!===========\n");
            	}
			}
			
		});
		
		list2.addMouseListener(new MouseAdapter() {

			@Override
			public void mouseClicked(MouseEvent e) {
				// TODO Auto-generated method stub
				area.append("=================当前用户不在线！=============\n");
			}

		
		});
		
	}
	
	
	public void ShashSelf() {
		this.use.updateUI();
	}
	
	
	public void CloseSelf() {//将自己关闭
		try {
			socket.close();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	
	public void ReadMess() {
		 //读取服务器返回的消息
		try {
			BufferedReader br = new BufferedReader(new InputStreamReader(in));
	        String mess1 = br.readLine();
		while(true) {
        
        //私聊消息
        
        System.out.println("mess1："+mess1);
        System.out.println("****************************************");
        
        
        
        	
        /*while(mess1.equals("4")) {//刷新
        		this.use.revalidate();
        		mess1=br.readLine();
        		 System.out.println("mess1："+mess1);
        	        System.out.println("****************************************");
        	}*/
        
        
        while(mess1.equals("1")) {//私聊
        	System.out.println("*********收到信息**************\n");
        	String mess2=br.readLine();//用户号
        	System.out.println("发信息的用户号为"+mess2);
        	String mess3=br.readLine();//信息
        	System.out.println("私信为"+mess3);
        	area.append("客户"+mess2+"对您私聊说:  ");
        	area.append(mess3+"\n");
        	
        	mess1=br.readLine();//刷新mess1
        	 System.out.println("mess1："+mess1);
             System.out.println("****************************************");
        }
        
        //群聊消息
        while((mess1.equals("2"))) {
        	String mess2=br.readLine();
        	if(mess2.equals("4")) {
        		//this.use.revalidate();
        		//use.repaint();
        		String WhoisOnline[]=SQL.WhoisOnline();
        		list1.setListData(WhoisOnline);
        		String WhoisNotOnline[]=SQL.WHoisnotOnline();
        		list2.setListData(WhoisNotOnline);
        		System.out.println("2中收到四号消息");
        		mess1=br.readLine();
        	}else {
        	area2.append(mess2+"\n");
        	mess1=br.readLine();
        	 System.out.println("mess1："+mess1);
             System.out.println("****************************************");
           }
        }
        
       while((mess1.equals("3"))) {//终止
        	br.close();
        	bw.close();
        	in.close();
        	out.close();
        	this.socket.close();
        	mess1="";
        	this.runnning=false;
        	SqlServer.DeleteUser(this.userinfor.get_name());
        }
        
        if(!this.runnning) {
        	break;
        }
     }
        
	     }catch(Exception e) {
	    	 e.printStackTrace();
	   }
  }
	
	

	}
	
	
}

import numpy as np
import matplotlib as mp
from pylab import *

figure(figsize=(16,6),dpi=80)
subplot(1,1,1)
#创建等差数列
X=np.linspace(-np.pi,np.pi,256,endpoint=True)
c,s=np.cos(X),np.sin(X)
#绘制余弦曲线
plot(X,c,color="blue",linewidth=1.0,linestyle="-")
#绘制正弦曲线
plot(X,s,color="green",linewidth=1.0,linestyle="-")
xlim(-4.0,4.0)
#设置上下限,设置横轴标记符
xticks(np.linspace(-4,4,9,endpoint=True))
ylim(-1.0,1.0)
yticks(np.linspace(-1,1,5,endpoint=True))

#设置边界
xlim(X.min()*(1.1),X.max()*1.1)
ylim(c.min()*1.1,c.max()*1.1)

#设置记号
xticks([-np.pi,-np.pi/2,0,np.pi/2,np.pi],[r'$-\pi$',r'$-\pi/2$',r'$0$',r'$+\pi/2$',r'$+\pi$'])
yticks([-1,0,+1],[r'$-1$',r'$-\pi/2$',r'$0$',r'$+\pi/2$',r'$+\pi$'])



savefig("exciese1",dpi=72)

import matplotlib.pyplot as plt
import numpy as np
from sklearn import datasets,linear_model
from sklearn.metrics import mean_squared_error,r2_score

#加载数据集
diabetes=datasets.load_diabetes()
diabetes_X=diabetes.data[:,np.newaxis,2]

diabetes_x_train=diabetes_X[:-20]
diabetes_x_test=diabetes_X[-20:]

diabetes_y_train=diabetes.target[:-20]
diabetes_y_test=diabetes.target[-20:]


regr=linear_model.LinearRegression()
regr.fit(diabetes_x_train,diabetes_y_train)

diabetes_y_predict=regr.predict(diabetes_x_test)

#系数
print(regr.coef_)
#均方差
print("%.2f"%mean_squared_error(diabetes_y_test,diabetes_y_predict))
#预测
print("得分：%.2f"%r2_score(diabetes_y_test,diabetes_y_predict))

#绘制结果
plt.scatter(diabetes_x_test,diabetes_y_test,color='black')
plt.plot(diabetes_x_test,diabetes_y_predict,color='blue',linewidth=3)
plt.xticks()
plt.yticks()
plt

import numpy as np
import matplotlib.pyplot as plt

x=np.arange(0.,5.,0.2)
plt.plot(x,x**4,'r',x,x*90,'bs',x,x**3,'g^')
plt.show()
print(help(plt.plot))

Parameters
    ----------
    x, y : array-like or scalar
        The horizontal / vertical coordinates of the data points.
        *x* values are optional. If not given, they default to
        ``[0, ..., N-1]``.
    
        Commonly, these parameters are arrays of length N. However,
        scalars are supported as well (equivalent to an array with
        constant value).
    
        The parameters can also be 2-dimensional. Then, the columns
        represent separate data sets.