天池平台 --- 工业AI大赛智能制造质量预测

最新推荐文章于 2024-05-06 07:00:00 发布
最新推荐文章于 2024-05-06 07:00:00 发布
阅读量2.7k 收藏 31
点赞数 1
分类专栏： 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35865125/article/details/88208068
版权

赛题：https://tianchi.aliyun.com/competition/entrance/231633/information

基于Python的解决方案：

原始jupyter文件，网盘： 链接：https://pan.baidu.com/s/1guIwAlk9zvI3ULcZ8kkBnw 提取码：g0xs

主要关注数据处理的方法，神经网络建立的方法，逻辑次要。

相关工具包：

import tensorflow as tf
import pandas as pd
import numpy as np
import seaborn as sns#安装anacoda后，利用anacoda的指令在安装的，见收藏夹kaggle中的帖子
import pylab  
import matplotlib.pyplot as plt
import matplotlib.cm as cm
from sklearn.decomposition import PCA
from pandas import Series,DataFrame
from tensorflow.python.framework import ops

1 数据预处理

1）利用pandas读入csv格式的文件：

# read  data from CSV file 
#train_data是一个DataFrame
train_data = pd.read_csv('C:/Users/FrankFang/Desktop/TianChiDATA/Train.csv')
train_data.info()#输出读入的csv数据的基本信息
print('train_data({0[0]},{0[1]})'.format(train_data.shape))#第一行的标题不被计入总行数
#默认输出矩阵的前5行, 必须放在一个jupyter输入格子的最后一句，才能显示出表格，用print (data.head())则可以，但是没有表格的形式
train_data.head()
输出：
train_data(500,8029)
 IDTOOL_ID210X1210X2210X3210X4210X5210X6210X7210X8...750X1444750X1445750X1446750X1447750X1448750X1449750X1450750X1451750X1452Y
0ID001N102.050.4650.271.43067.454.620-0.54-1.05...0.000720.0007225.70.000720.0007225.70.000720.000722.400000e+122.945079
1ID002M100.950.8050.223.47762.083.412-2.121.02...0.000720.0007225.50.000720.0007225.50.000720.000722.400000e+122.955092
2ID003L98.560.5550.241.17256.703.080-2.250.88...0.000640.0006425.20.000640.0006425.20.000640.000642.400000e+122.741264
3ID004M100.350.9010.223.63162.253.949-1.980.82...0.000720.0007226.40.000720.0007226.40.000720.000722.400000e+122.799336
4ID005M100.250.8540.233.42961.423.630-1.891.02...0.000720.0007226.40.000720.0007226.40.000720.000722.400000e+122.692093

5 rows × 8029 columns

2）使用random包随机重新排列个样本（重排矩阵的各个行）

#shutttle 各行数据
import random as rd  # 导入random模块，使用里面的sample函数

train_data_tem=train_data

#随机排列所有的training set:
train_data_tem.sample(frac=1)

3）将非数字类型的列替换为数字

分析处理信息不完整的数据，如果某一个列中有空，则用该列的平均值来填补. 非数字类型的列： Tool,,Tool (#2), ,tool (#1), TOOL,TOOL (#1)，TOOL (#2)，， TOOL_ID,TOOL_ID (#1),TOOL_ID (#2),TOOL_ID (#3),

train_data["Tool"].loc[train_data["Tool"] == "A"] = 1.0
train_data["Tool"].loc[train_data["Tool"] == "B"] = -1.0

train_data["Tool (#2)"].loc[train_data["Tool (#2)"] == "A"] = 1.0
train_data["Tool (#2)"].loc[train_data["Tool (#2)"] == "B"] = 0.0
train_data["Tool (#2)"].loc[train_data["Tool (#2)"] == "C"] = -1.0


train_data["tool (#1)"].loc[train_data["tool (#1)"] == "P"] = 1.2
train_data["tool (#1)"].loc[train_data["tool (#1)"] == "Q"] = 1.0
train_data["tool (#1)"].loc[train_data["tool (#1)"] == "R"] = 0.8
train_data["tool (#1)"].loc[train_data["tool (#1)"] == "S"] = 0.6
train_data["tool (#1)"].loc[train_data["tool (#1)"] == "T"] = 0.4
train_data["tool (#1)"].loc[train_data["tool (#1)"] == "U"] = 0.2
train_data["tool (#1)"].loc[train_data["tool (#1)"] == "V"] = 0.0
train_data["tool (#1)"].loc[train_data["tool (#1)"] == "W"] = -0.2
train_data["tool (#1)"].loc[train_data["tool (#1)"] == "X"] = -0.4

train_data["TOOL"].loc[train_data["TOOL"] == "B"] = 1.0
train_data["TOOL"].loc[train_data["TOOL"] == "C"] = 0.0
train_data["TOOL"].loc[train_data["TOOL"] == "D"] = -1.0

train_data["TOOL (#1)"].loc[train_data["TOOL (#1)"] == "XY1"] = 1.0 
train_data["TOOL (#1)"].loc[train_data["TOOL (#1)"] == "YX1"] = -1.0


train_data["TOOL (#2)"].loc[train_data["TOOL (#2)"] == "A"] = 1.0
train_data["TOOL (#2)"].loc[train_data["TOOL (#2)"] == "B"] = -1.0
#print((train_data["TOOL (#2)"][7]))

train_data["TOOL_ID"].loc[train_data["TOOL_ID"] == "J"] = 1.0
train_data["TOOL_ID"].loc[train_data["TOOL_ID"] == "K"] = 0.7
train_data["TOOL_ID"].loc[train_data["TOOL_ID"] == "L"] = 0.4
train_data["TOOL_ID"].loc[train_data["TOOL_ID"] == "M"] = 0.1
train_data["TOOL_ID"].loc[train_data["TOOL_ID"] == "N"] = -0.2
train_data["TOOL_ID"].loc[train_data["TOOL_ID"] == "O"] = -0.5

train_data["TOOL_ID (#1)"].loc[train_data["TOOL_ID (#1)"] == "E"] = 1.0
train_data["TOOL_ID (#1)"].loc[train_data["TOOL_ID (#1)"] == "N"] = -1.0

train_data["TOOL_ID (#2)"].loc[train_data["TOOL_ID (#2)"] == "C"] = 1.0
train_data["TOOL_ID (#2)"].loc[train_data["TOOL_ID (#2)"] == "D"] = 0.0
train_data["TOOL_ID (#2)"].loc[train_data["TOOL_ID (#2)"] == "E"] = -1.0

train_data["TOOL_ID (#3)"].loc[train_data["TOOL_ID (#3)"] == "E0"] = 1.0
train_data["TOOL_ID (#3)"].loc[train_data["TOOL_ID (#3)"] == "N0"] = -1.0

4）将空单元格用其所在列的中位数进行替换
5）若某列的值全部相同则直接去掉该列

for i in range(1,8028 ):#i=1,2,...,8027
    train_data[ train_data.columns[i] ].fillna( train_data[ train_data.columns[i] ].median(), inplace=True )

#如果某一列中都为相同的数，则直接删除该列,如果是tool列不要删，因为后面还要使用“tool”检测tool列的列标
#
Dropped_columnNames=[]#保存被drop的列名字，同样需要对test data中的这些列进行drop
a=0
train_data_temp = train_data
for i in range(1,8028):
    CloumnName = train_data.columns[i]
    if (0 == train_data[CloumnName].max() - train_data[CloumnName].min() ) and (not("tool" in CloumnName.lower())):
        if a !=0:#保留一列
            train_data_temp = train_data_temp.drop([CloumnName], axis=1)
            Dropped_columnNames.append(CloumnName)
        a=a+1
        #print(CloumnName)
        #print(train_data[CloumnName].max() - train_data[CloumnName].min())
train_data = train_data_temp
print(a)    

      
train_data_rows = train_data.shape[0]#返回列数，，shape[0]返回行数 #包括第一列的id和最后一列的Y
train_data_colums = train_data.shape[1]#
print(train_data_rows,train_data_colums)

6）计算各个列（各个属性）与Y列（预测值）的相关系数的绝对值，并排序。取前50个或其他合适的数目。

#去掉train_data中的ID列
train_data = train_data.drop(["ID"], axis=1)

#计算各列（除了ID列）与Y列的相关系数
#
train_data.head()
train_data_coorY = train_data.corrwith(train_data["Y"]).abs()
train_data_coorY = train_data_coorY.sort_values(ascending = False)#从大到小排序，
#print(train_data_coorY)
#保存于Y列的相关系数排名前x的列：(注意train_data_coorY第一名为Y列本身)
Column_names_high_corr=[]
Num_selectd_colums=50
for i in range(1,Num_selectd_colums+1):
    if not("tool" in train_data_coorY.index[i].lower()):
        Column_names_high_corr.append(train_data_coorY.index[i])
    
#将所有的Tool列补上
for i in range(1,train_data_colums-1):
    CloumnName = train_data.columns[i]
    if "tool" in CloumnName.lower():
        Column_names_high_corr.append(CloumnName)

Num_selectd_colums=len(Column_names_high_corr)

#将"Y"补放在最后
Column_names_high_corr.append("Y")

#仅仅留train_data中Column_names_high_corr[]中保存的列:
print(train_data.shape)
train_data = train_data[Column_names_high_corr]
    
print(train_data.shape)
train_data.head()

另外一种，通过PCA来进行特征压缩的方法：

基于sklearn包：(前面已经导入)

m = PCA(n_components=0.9) #保留90%的数据信息

array_PCA = m.fit_transform(array) #array是原始矩阵，pandas的datafram。该步骤同时保留了这个pca模型。 array_PCA是压缩后的数据

#用上面的model来对新数据做PCA

NewArray_PCA = m.transform(NewArray)

 

7）按照80%和20%的比例将训练样本分成两部分，前80%用于训练模型，后20%用于测试训练出的模型的好坏,将train_data转换成numpy数组。

#将training data set分成两个部分：(去掉最后一列（Y）)
train_data_part1=train_data.iloc[0:int(train_data_rows*0.8),0:train_data_colums-1]
train_data_part2=train_data.iloc[int(train_data_rows*0.8):train_data_rows,0:train_data_colums-1]

#将train_data_part1，train_data_part2转换为numpy数组类型,方便后续使用numpy 的broad casting
train_data_part1 = np.array(train_data_part1)
train_data_part2 = np.array(train_data_part2)
#print(train_data_part1[0:2,0:3])

train_data_part1_rows = train_data_part1.shape[0]#
train_data_part1_colums = train_data_part1.shape[1]#

train_data_part2_rows = train_data_part2.shape[0]#
train_data_part2_colums = train_data_part2.shape[1]#
print(type(train_data_part1))


print(train_data_part1_rows,train_data_part1_colums)
print(train_data_part2_rows,train_data_part2_colums)

8） 计算80%部分的样本的各列max, min, 均值，标准差，并用这些值对全部的labeled样本进行归一化： (data - 均值) /  标准差

#求train_data_part1_PCA各列的均值和最大值，最小值，并保存..train_data_PCA不包括ID列和Y列
train_data_part1_mean = train_data_part1.mean(axis=0).reshape(1,train_data_part1_colums)#数组按照列求平均
train_data_part1_max = train_data_part1.max(axis=0).reshape(1,train_data_part1_colums)#数组按照列求max
train_data_part1_min = train_data_part1.min(axis=0).reshape(1,train_data_part1_colums)#数组按照列求min
train_data_part1_maxMinumMin = train_data_part1_max-train_data_part1_min#求各列的max-min值并保存
train_data_part1_maxMinumMin = train_data_part1_maxMinumMin + 0.0001#防止为零

train_data_part1_std = train_data_part1.std(axis=0).reshape(1,train_data_part1_colums)+0.0001#数组按照列求std

print(train_data_part1_mean.shape)

#对各列进行rescale: x=(x-mean)/(max-min)
print(train_data_part1_mean.shape)
print(type(train_data_part1))
train_data_part1 = train_data_part1 - train_data_part1_mean###np array类型的才能broad casting!!!!
#train_data_part1 = train_data_part1 / train_data_part1_maxMinumMin#利用python的broadcasting 
train_data_part1 = train_data_part1 / train_data_part1_std
print(train_data_part1.shape)

train_data_part2 = train_data_part2 - train_data_part1_mean###np array类型的才能broad casting!!!!
#train_data_part2 = train_data_part2 / train_data_part1_maxMinumMin#利用python的broadcasting
train_data_part2 = train_data_part2 / train_data_part1_std
print(train_data_part2.shape)

9）读取100个unlabeled数据，并做与上面同样的预处理。

2 基于TensorFlow包搭建神经网络

大体思路是，先建立起来前向传播公式，公式中参与运算的是tensorflow的placeholder。 然后，在实际训练中用实际的数据来替换掉placeholder。

1）函数：为X,Y,dropout rate,learning rate 生成placeholder，这些placeholder参与公式运算，矩阵的话需要有确定的列数。

def create_placeholders(Feature_Num):
    #定义placeholder
    x = tf.placeholder('float', shape=[None, Feature_Num])
    # labels
    y = tf.placeholder('float', shape=[None, 1])
    #keep_prob用来表示神经元的输出概率
    keep_prob=tf.placeholder(tf.float32)
    keep_learnRate=tf.placeholder(tf.float32)
    return x,y,keep_prob,keep_learnRate

2) 函数： 参数初始化，使用的是tr.variable，初始化各层之间的参数矩阵以及bias列向量

def initialize_parameters(Feature_Num,Layer1_NodeNum,Layer2_NodeNum,Layer3_NodeNum,Layer4_NodeNum,Layer5_NodeNum,Layer6_NodeNum):
    """
    Initializes weight parameters to build a neural network with tensorflow. The shapes are:
  
    Returns:
    parameters -- a dictionary of tensors containing W1, W2
    """
    #print("initialize_parameters() is called!")
    #print(Feature_Num,Layer1_NodeNum,Layer2_NodeNum,Layer3_NodeNum)
#     W1 = tf.get_variable("W1", [Feature_Num,Layer1_NodeNum], initializer = tf.contrib.layers.xavier_initializer(seed = 0))
#     W2 = tf.get_variable("W2", [Layer1_NodeNum,Layer2_NodeNum], initializer = tf.contrib.layers.xavier_initializer(seed = 0))
#     W3 = tf.get_variable("W3", [Layer2_NodeNum,Layer3_NodeNum], initializer = tf.contrib.layers.xavier_initializer(seed = 0))
#     W4 = tf.get_variable("W4", [Layer3_NodeNum,Layer4_NodeNum], initializer = tf.contrib.layers.xavier_initializer(seed = 0))
    
#     Bias1 = tf.get_variable("Bias1", [Layer1_NodeNum], initializer = tf.contrib.layers.xavier_initializer(seed = 0))
#     Bias2 = tf.get_variable("Bias2", [Layer2_NodeNum], initializer = tf.contrib.layers.xavier_initializer(seed = 0))
#     Bias3 = tf.get_variable("Bias3", [Layer3_NodeNum], initializer = tf.contrib.layers.xavier_initializer(seed = 0))
#     Bias4 = tf.get_variable("Bias4", [Layer4_NodeNum], initializer = tf.contrib.layers.xavier_initializer(seed = 0))

    tf.set_random_seed(1)  
    W1 =tf.Variable(tf.truncated_normal([Feature_Num,Layer1_NodeNum], stddev=0.1))
    W2 =tf.Variable(tf.truncated_normal([Layer1_NodeNum,Layer2_NodeNum], stddev=0.1))
    W3 =tf.Variable(tf.truncated_normal([Layer2_NodeNum,Layer3_NodeNum], stddev=0.1))
    W4 =tf.Variable(tf.truncated_normal([Layer3_NodeNum,Layer4_NodeNum], stddev=0.1))
    W5 =tf.Variable(tf.truncated_normal([Layer4_NodeNum,Layer5_NodeNum], stddev=0.1))
    W6 =tf.Variable(tf.truncated_normal([Layer5_NodeNum,Layer6_NodeNum], stddev=0.1))
    
    Bias1 =tf.Variable(tf.truncated_normal([Layer1_NodeNum], stddev=0.1))
    Bias2 =tf.Variable(tf.truncated_normal([Layer2_NodeNum], stddev=0.1))
    Bias3 =tf.Variable(tf.truncated_normal([Layer3_NodeNum], stddev=0.1))
    Bias4 =tf.Variable(tf.truncated_normal([Layer4_NodeNum], stddev=0.1))
    Bias5 =tf.Variable(tf.truncated_normal([Layer5_NodeNum], stddev=0.1))
    Bias6 =tf.Variable(tf.truncated_normal([Layer6_NodeNum], stddev=0.1))
    
    parameters = {"W1": W1,"W2": W2,"W3": W3,"W4": W4,"W5": W5,"W6": W6,"Bias1": Bias1,"Bias2": Bias2,"Bias3": Bias3,"Bias4": Bias4,"Bias5": Bias5,"Bias6": Bias6}

    return parameters

3）函数：前向传播函数

 入参：两个placeHolder，还有parameters; 返回预测值

def forward_propagation(x, parameters,keep_prob):
    """
     Arguments:
    x -- input dataset placeholder, of shape (input size, FeatureNum)
    parameters -- python dictionary containing your parameters "W1", "W2"..
                  the shapes are given in initialize_parameters
    keep_prob--dropout related
    
    Returns:
    Z3 -- the output of the last LINEAR unit
     """
    # Retrieve the parameters from the dictionary "parameters" 
    W1 = parameters['W1']
    W2 = parameters['W2']
    W3 = parameters['W3']
    W4 = parameters['W4']
    W5 = parameters['W5']
    W6 = parameters['W6']
    
    Bias1 = parameters["Bias1"]
    Bias2 = parameters["Bias2"]
    Bias3 = parameters["Bias3"]
    Bias4 = parameters["Bias4"]
    Bias5 = parameters["Bias5"]
    Bias6 = parameters["Bias6"]
    
    Z1=tf.matmul(x,W1) + Bias1#x(?,1) w1(1,12)
    #A1=tf.nn.tanh(Z1)
    #A1=tf.nn.relu(Z1)
    A1 = Z1
    A1_drop=tf.nn.dropout(A1,keep_prob)
    
    Z2=tf.matmul(A1_drop,W2) + Bias2#A1_drop(?,12) w2(12,1)
    #A2=tf.nn.tanh(Z2)
    #A2=tf.nn.relu(Z2)
    A2 = Z2
    A2_drop=tf.nn.dropout(A2,keep_prob)
    
    Z3=tf.matmul(A2_drop,W3) + Bias3
    A3=Z3
    #A3=tf.nn.tanh(Z3)
    #A3=tf.nn.relu(Z3)
    A3_drop=tf.nn.dropout(A3,keep_prob)
    
    Z4=tf.matmul(A3_drop,W4) + Bias4
    A4=Z4 
    #A4=tf.nn.relu(Z4)
    #A4=tf.nn.tanh(Z4)
    A4_drop=tf.nn.dropout(A4,keep_prob)
    
    Z5=tf.matmul(A4_drop,W5) + Bias5
    A5=Z5 
    #A5=tf.nn.relu(Z5)
    #A5=tf.nn.tanh(Z5)
    A5_drop=tf.nn.dropout(A5,keep_prob)
    
    Z6=tf.matmul(A5_drop,W6) + Bias6
    A6=Z6 
    #A6=tf.nn.relu(Z6)
    
    return A6

4）函数：损失函数

入参：预测值和实际的y值，都是inputsize*1的placeholder

返回：数值

def compute_cost(predict,y):
    cost= tf.reduce_mean( tf.square(y-predict))
    #cost= tf.reduce_mean( predict-predict)
    #cost= 0
    return cost

5）函数：模型

运行这个model（）函数就可以得到一个模型，入参中的learning_rate, num_epochs，minibatch_size都是可以调节的参数，可以手动调节，也可以另外写一个函数，自动用不同的入参去调用model函数，寻找更好的参数。

该函数可以将训练过程中的cost打印出来，观察训练过程。

def model(X_train, Y_train, X_test, Y_test,X_NeedPredi, learning_rate = 0.8,
          num_epochs = 10, minibatch_size = 10, print_cost = True):
    #适用于X为二维数据，一行代表一个sample，Y为一列 
    #X_test, Y_test用于对训练出的model进行测试
    
    #ops.reset_default_graph()                         # to be able to rerun the model without overwriting tf variables
    tf.reset_default_graph()
    
    (X_train_rows, X_train_columns) = X_train.shape
    (Y_train_rows, Y_train_columns) = Y_train.shape
    assert(X_train_rows == Y_train_rows)
    (X_test_rows, X_test_columns) = X_test.shape
    (Y_test_rows, Y_test_columns) = Y_test.shape
    assert(X_test_rows == Y_test_rows)
    assert(X_train_columns == X_test_columns)
    
    (X_NeedPredi_rows, X_NeedPredi_columns) = X_NeedPredi.shape
    assert(X_train_columns == X_NeedPredi_columns)
    
    #########################################################
    mini_batch_num = int(X_train_rows/minibatch_size)
    
    #########################################################
    Feature_Num = X_train_columns
    x, y, keep_prob,keep_learnRate = create_placeholders(Feature_Num)#Feature_Num
    #parameters = initialize_parameters(Feature_Num,200,100,80,50,25,1)
    parameters = initialize_parameters(Feature_Num,50,50,20,10,5,1)
    
    A3 = forward_propagation(x, parameters,keep_prob)
    predict = A3
    cost = compute_cost(predict, y)
    cost_v2 = compute_cost_v2(predict, y)
    
    optimizer = tf.train.AdamOptimizer(learning_rate).minimize(cost)
    #########################################################
    cost_validations = []
    cost_stepValues=[]
    x_range = []
    
    ########################################################
    init = tf.global_variables_initializer()
    
    with tf.Session() as sess:
        sess.run(init)#在session开始时，需要初始化前面的各个函数创建的变量
        #print("W1 = " + str(parameters["W1"].eval()))
        for epoch in range(num_epochs):
            New_learnRate = learning_rate*(0.99**epoch)
            
            for i in range(mini_batch_num):
                
                batch_xs = X_train[i*minibatch_size : (i+1)*minibatch_size , 0:Feature_Num]
                batch_ys = Y_train[i*minibatch_size : (i+1)*minibatch_size]
                
                if print_cost == True and (i%200) == 0:  
                    validation_cost = cost.eval( feed_dict={ x:X_test, y:Y_test,keep_prob:1.0 } )
                    cost_current = cost.eval( feed_dict={ x:batch_xs,y:batch_ys,keep_prob:1.0 } )

                    cost_validations.append(validation_cost)
                    cost_stepValues.append(cost_current)
                    x_range.append(i + epoch*mini_batch_num)

                    #print("Iter= " + str(i+epoch*mini_batch_num) + ",Current training batech's cost= " + str(cost_current) + ",cost_validation= " + str(validation_cost))

                sess.run(optimizer,feed_dict={x:batch_xs,y:batch_ys,keep_prob:0.2,keep_learnRate:New_learnRate}) 
        
#         print("W1 = " + str(parameters["W1"].eval()))
#         print("Bias1 = " + str(parameters["Bias1"].eval()))
#         print("W2 = " + str(parameters["W2"].eval()))
#         print("Bias2 = " + str(parameters["Bias2"].eval()))
#         print("W3 = " + str(parameters["W3"].eval()))
#         print("Bias3 = " + str(parameters["Bias3"].eval()))
        if print_cost == True :  
            plt.plot(x_range, cost_validations,'-b', label='validation set')
            plt.plot(x_range, cost_stepValues,'-r', label='setp cost')
            plt.legend(loc='lower right', frameon=False)
            plt.ylim(ymax = 0.6, ymin = 0)
            plt.ylabel('cost')
            plt.xlabel('step')
            #plt.plot(x_range, cost_values,'-b')
            plt.show()
        
        #############利用已经训练出来的模型对X_test数据进行预测!并将预测结果与Y_test比较，计算出cost,以进行评估。太激动了#################################
       
        predict_Y_test = np.zeros( X_test_rows ).reshape( X_test_rows,1 )
        
        minibatch_size=10
        for i in range( int(X_test_rows/minibatch_size) ): #对X_test数据进行预测
            #print(i)
            #print(X_NeedPredi[i*1 : (i+1)*1,0:Feature_Num])
            predict_Y_test[i*minibatch_size : (i+1)*minibatch_size] = predict.eval(feed_dict={x: X_test[i*minibatch_size : (i+1)*minibatch_size,0:Feature_Num],keep_prob: 1.0})
        #print('predict_testA({0})'.format(len(predict_test)))
        
        cost_predict_Y_test = cost.eval( feed_dict={ x:X_test,y:Y_test,keep_prob:1.0 } )
        #print("learning_rate="+str(learning_rate)+"minibatch_size="+str(minibatch_size)+"cost_predict_Y_test=") 
        print(cost_predict_Y_test)
        #print(predict_Y_test)
        
        ############利用模型对没有label的数据进行预测##############################
#         predict_Y = np.zeros( X_NeedPredi_rows ).reshape( X_NeedPredi_rows,1 )
        
#         minibatch_size=10
#         for i in range( int(X_NeedPredi_rows/minibatch_size) ):
#             #print(i)
#             #print(X_NeedPredi[i*1 : (i+1)*1,0:Feature_Num])
#             predict_Y[i*minibatch_size : (i+1)*minibatch_size] = predict.eval(feed_dict={x: X_NeedPredi[i*minibatch_size : (i+1)*minibatch_size,0:Feature_Num],keep_prob: 1.0})
#         print('predict_Y({0})'.format(len(predict_Y)))
#         print("predicted labels for the unbled data:predict_Y=")
#         print(predict_Y)
        return  cost_predict_Y_test
        #return cost_predict_Y_test

 

 

 

 

 

 

First Snowflakes
关注
  • 1
    点赞
  • 踩
  • 31
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 9
    评论
专栏目录
天池大数据比赛-智能制造质量预测.zip
09-30
天池大数据比赛-智能制造质量预测
天池AI大赛 智能制造预测赛题
Jacoob1024的博客
04-16 1490
一、赛题与要求的简单介绍   （多特征少样本问题）          本次比赛提供的是生产线上不同工序的生产数据（具体代表什么含义未可知），通过这些数据构建特征，设计模型，预测与之对应的生产数值。评判标准采用MSE，计算单个样本预测值与真实值的差距，再对所有样本进行MSE求和，最后取平均作为评判标准。二、数据描述     数据包括ID列、工具列和数据列，他们有自己的命名格式。数据从形式上主要按照工...
天池工业AI大赛-智能制造质量预测
dataastron的博客
01-13 2758
竞赛笔记ID466记录丢弃750X1452，750X1350，750X1442,750X717,750X718,420X186 这几个字段去掉代表TOOL_ID后面的一些列一直到下一个TOOL_ID，一系列工序都是在这个机台上进行的 一个完整工序里的不同工位提交第一列不能是index在交叉验证的时候用cross_val_score(etr, x_train, y_train, cv=10, sco
机器学习实战 —— 工业蒸汽量预测（总）
最新发布
ZShiJ的博客
05-06 1867
燃料在燃烧时加热水生成蒸汽，蒸汽压力推动汽轮机旋转，然后汽轮机带动发电机旋转，产生电能。在这一系列的能量转化中，影响发电效率的核心是锅炉的燃烧效率，即燃料燃烧加热水产生高温高压蒸汽。 数据分析：查看变量间相关性以及找出关键变量。 数据特征工程对数据精进：异常值处理、归一化处理以及特征降维。 模型训练(涉及主流ML模型)：决策树、随机森林，lightgbm等。 模型验证：评估指标以及交叉验证等。 特征优化：用lgb对特征进行优化。 模型融合：进行基于stacking方式模型融合。
工业AI项目-持续学习更新中
HJZ11的博客
07-16 1021
文章目录1.AI工业项目介绍1.1 天池7号馆1.1.1 布匹缺陷检测1.比赛链接2.方案链接1.1.2 铝型材表面瑕疵识别1.比赛链接2.方案链接1.1.3 包裹X光限制品监测-语义分割1.比赛链接2.方案链接1.2 天池学习赛1.2.1 街景字符编码识别1.比赛链接2.方案链接1.2.2 工业蒸汽量预测1.比赛链接2.方案链接 1.AI工业项目介绍 1.1 天池7号馆 1.1.1 布匹缺陷检测 佛山南海纺织布匹图像缺陷检测 1.比赛链接 天池七号馆-比赛链接地址 2.方案链接 1.1.2 铝型材表面瑕疵
天池工业Al大赛-智能制造质量预测
m0_37468171的博客
10-18 2384
赛题 产品特性预测 赛题背景： 半导体产业是一个信息化程度高的产业。高度的信息化给数据分析创造了可能性。基于数据的分析可以帮助半导体产业更好的利用生产信息，提高产品质量。 现有的解决方案是，生产机器生产完成后，对产品质量做非全面的抽测，进行产品质量检核。这往往会出现以下状况，一是不能即时的知道质量的好坏，当发现质量不佳的产品时，要修正通常都为时以晚，二是在没有办法全面抽测的状况下，存在很大漏检...
天池工业AI大赛-智能制造质量预测 比赛历程和技术方案总结复赛48名
EWilsen
01-31 4646
一、参赛 研二导师的项目摸鱼结束后，思考了一下出路，项目和机器学习相关，重在特征提取的传统算法研究和目标识别的多样算法融合，简单说就是理论，MATLAB，推导三要素组成。来年就要面对就业，没有点成果或者简历上写的料，感觉就凉了，正好自己用一个星期的时间把python实战的方法过来一边，代码就大概看了看，感觉武器已经备好，可以开始作战，所以和同团队的小伙伴一拍即合，做比赛。这也正好是第一次
天池大数据比赛.zip
08-24
全国大学生电子设计竞赛（National Undergraduate Electronics Design Contest），试题，解决方案及源码。计划或参加电赛的同学可以用来学习提升和参考。程序均是实战案例，经过测试可直接运行。 全国大学生电子设计竞赛（National Undergraduate Electronics Design Contest），试题，解决方案及源码。计划或参加电赛的同学可以用来学习提升和参考。程序均是实战案例，经过测试可直接运行。
天池智能制造质量预测数据集.rar
09-09
天池智能制造质量预测数据集 背景描述 半导体产业是一个信息化程度高的产业。高度的信息化给数据分析创造了可能性。基于数据的分析可以帮助半导体产业更好的利用生产信息，提高产品质量。 现有的解决方案是，生产机器生产完成后，对产品质量做非全面的抽测，进行产品质量检核。这往往会出现以下状况，一是不能即时的知道质量的好坏，当发现质量不佳的产品时，要修正通常都为时以晚，二是在没有办法全面抽测的状况下，存在很大漏检的风险。 在机器学习，人工智能快速发展的今天，我们希望着由机器生产参数去预测产品的质量，来达到生产结果即时性以及全面性。更进一步的，可基于预先知道的结果，去做对应的决策及应变，对客户负责，也对制造生产更加敏感。 痛点与挑战： 1）TFT-LCD（薄膜晶体管液晶显示器）的生产过程较为复杂，包含几百道以上的工序。每道工序都有可能会对产品的品质产生影响，故算法模型需要考虑的过程变量较多。 2）另外，这些变量的取值可能会存在异常（如测点仪表的波动导致、设备工况漂移等现象），模型需要足够稳定性和鲁棒性。 3）产线每天加工的玻璃基板数以万计，模型需要在满足较高的精准度前提下尽可能实时得到预测结果，这样才能给在实际生产中进行使用。 价值： 1）如果能够建立算法模型准确预测出特性值，便可以实现生产过程的实时监控和预警，提前发现当前工序的问题、避免问题流入到后道工序，减少生产资源浪费的同时也优化了产品良率。 2）基于预测模型得到的关键参数，工艺人员能够快速地针对那些电性表现不佳的产品进行问题溯源分析，重点分析和调整那些关键的影响因子，加快不良问题的处理、提高整体工艺水平。 3）该预测模型在部署后也可以用于减少特性检测相关的工序，能够节约检测资源并且对提升产线整体的产能有正面作用。 数据说明 每条数据包含8029列字段。 第一个字段为ID号码，最后一列为要预测的值Y。其余的数据为用于预测Y的变量X。这些变量一共由多道工序组成，字段的名字可以区分不同的工序，例如 210X1, 210X2。300X1,300X2。字段中的TOOL_ID或者Tool为每道工序使用的机台，如果是string类型，需要选手自行进行数字化转换。注意： 数据中存在缺失值。 测试集分为A/B两份，相比训练集，最后一列的value值是缺失的，研究人员可以根据训练数据做模型训练，并对测试集做预测。为了方便研究人员评测算法效果，我们提供了测试集A的答案。 问题描述 本数据集提供了生产线上的抽样数据，反应机台的温度，气体，液体流量，功率，制成时间等因子。 通过这些因子，需要研究人员设计出模型，准确的预测与之相对应的特性数值。这是一个典型的回归预测问题。
天池工业AI大赛-智能制造质量预测比赛思路总结.zip
09-30
在“天池工业AI大赛-智能制造质量预测比赛思路总结”这个主题中，参赛者们聚焦于利用人工智能技术解决实际工业生产中的质量问题。这次比赛的核心任务是预测玻璃制造过程中的产品质量，通过对一系列生产数据进行分析...
《人工智能》--天池精准医疗大赛——人工智能辅助糖尿病遗传风险预测 第一赛季.zip
03-15
人工智能学习总结成果，希望可以帮到大家，有疑问欢迎随时沟通~ 人工智能学习总结成果，希望可以帮到大家，有疑问欢迎随时沟通~ 人工智能学习总结成果，希望可以帮到大家，有疑问欢迎随时沟通~ 人工智能学习总结...
天池工业ai初赛数据集
12-26
2017年12月天池工业ai比赛的初赛数据集，一共包括训练集、测试集A、测试集B
天池-student预测数据集
06-25
阿里天池比赛，关于机器学习，预测学生成绩数据，可以用来机器学习练手
Python-天池医疗AI大赛MaskRCNN肺部结节智能检测
08-11
Mask R-CNN for Pulmonary Nodules Diagnosis, using TensorFlow 天池医疗AI大赛：Mask R-CNN肺部结节智能检测（Segmentation Classification）
工业4.0-企业智能制造质量预测模型-人工智能-机器学习
toby001111的博客
03-17 4127
工业4.0-企业智能制造质量预测模型-人工智能-机器学习
手把手教你用GAN实现半监督学习
热门推荐
Double_V的博客
11-14 3万+
引言 本文主要介绍如何在tensorflow上仅使用200个带标签的mnist图像，实现在一万张测试图片上99%的测试精度，原理在于使用GAN做半监督学习。前文主要介绍一些原理部分，后文详细介绍代码及其实现原理。前文介绍比较简单，有基础的同学请掠过直接看第二部分，文章末尾给出了代码GitHub链接。对GAN不了解的同学可以查看微信公众号：机器学习算法全栈工程师 的GAN入门文章。 本博客中的代...
分布式深度学习最佳入门（踩坑）指南
qq_29462849的博客
01-11 1996
点击上方“计算机视觉工坊”，选择“星标”干货第一时间送达作者丨Lyon@知乎（已授权）来源丨https://zhuanlan.zhihu.com/p/294698838编辑丨极市平台导读...
源代码安装paddlepaddle 到云计算机——感谢百度云和人工智能项目paddlepaddle
bywetec的专栏
12-06 916
Paddlepaddle源代码安装
天池智能工业大赛大佬们的思路（需要再看）
hasy
02-07 1379
打酱油参加了天池工业AI大赛1，当然没拿到奖，看决赛答辩直播时见识到了大佬们的各种思路，真是大开眼界。记录一下，留给以后参考。 1. 特征构造 这个是相当重要的 第一名那个女孩子并没有用什么高深的方法，但是对特征挖掘的特别好，并且提到我们可能要 “人工”智能，即是人为创造数据。1） 通过每个特征原始值与均值的差异，差异的绝对值构造。2） 通过可能特征的四则运算构造特征（当然，这是剔除掉
天池大赛 零基础入门nlp - 新闻文本分类
10-24
天池大赛是国内知名的数据科学竞赛平台，零基础入门NLP - 新闻文本分类是其中的一项比赛任务。这个任务的目标是利用机器学习和自然语言处理的方法，对给定的新闻文本进行分类，即根据新闻内容判断其所属的类别。这个任务对于初学者来说是一个很好的入门项目。 在解决这个问题的过程中，我们需要首先对提供的训练数据进行探索性数据分析，了解数据的分布，词频以及类别的平衡情况。然后，我们可以进行文本预处理，包括分词、去除停用词、词干化等。接下来，可以构建特征表示，可以使用TF-IDF、Word2Vec或者其他词嵌入模型来提取文本的向量表示。在构建特征表示后，可以选择合适的机器学习算法，如朴素贝叶斯、支持向量机、深度学习等，来训练分类模型。 在进行模型训练之前，可以将数据集分为训练集和验证集，用于模型的评估和调优。我们可以使用交叉验证，调整模型的超参数，选择表现最好的模型。在模型训练完成后，可以使用测试集对模型进行评估，计算准确率、召回率和F1值等指标。最后，我们可以利用模型对给定的未知新闻文本进行分类预测。 在解决这个问题的过程中，还可以进行一些方法的优化和改进。比如，可以使用集成学习的方法，如随机森林、XGBoost或者LightGBM等，结合多个分类器的结果来提高整体的分类准确率。此外，可以尝试使用预训练的模型，如BERT等，来获得更好的特征表示。此外，还可以尝试使用深度学习网络，如卷积神经网络或者循环神经网络，来提取文本的高级语义特征。 总之，零基础入门NLP - 新闻文本分类是一个很好的机会，可以学习和应用自然语言处理的知识和技术。通过解决这个问题，我们可以深入了解文本分类的基本概念和方法，提升自己在数据科学领域的能力和竞争力。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

First Snowflakes

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值