代码＋预测分析，文件私信发哦（价格可商量）

Question

根据数据集选取适当的评价指标并对合理性进行说明；
用三种不同的分类算法与回归算法，进行预测；并以最后10天的数据作为验证；
使用图表对预测结果进行展示，并对预测结果进行分析，包括但不限于结果的意义、合理性等
并且根据结果给出解决方案

Answer 1

运行结果

Answer 2

文件给我一下

Answer 3

import pandas as pd  
import numpy as np  
from sklearn.model_selection import train_test_split  
from sklearn.preprocessing import MinMaxScaler  
from sklearn.linear_model import LinearRegression  
from sklearn.svm import SVC  
from sklearn.neighbors import KNeighborsRegressor  
from sklearn.ensemble import RandomForestRegressor  
from sklearn.tree import DecisionTreeRegressor  
from sklearn.metrics import mean_squared_error, r2_score
data = pd.read_csv("data.csv")  
X = data.drop("target", axis=1)  
y = data["target"]  
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
lr = LinearRegression()  
lr.fit(X_train, y_train)  
y_pred_lr = lr.predict(X_test)  
mse_lr = mean_squared_error(y_test, y_pred_lr)  
r2_lr = r2_score(y_test, y_pred_lr)  
print("线性回归结果：")  
print("均方误差:", mse_lr)  
print("R^2 得分:", r2_lr)
svm = SVC(kernel="linear")  
svm.fit(X_train, y_train)  
y_pred_svm = svm.predict(X_test)  
mse_svm = mean_squared_error(y_test, y_pred_svm)  
r2_svm = r2_score(y_test, y_pred_svm)  
print("支持向量机结果：")  
print("均方误差:", mse_svm)  
print("R^2 得分:", r2_svm)
knn = KNeighborsRegressor(n_neighbors=5)  
knn.fit(X_train, y_train)  
y_pred_knn = knn.predict(X_test)  
mse_knn = mean_squared_error(y_test, y_pred_knn)  
r2_knn = r2_score(y_test, y_pred_knn)  
print("K最近邻回归结果：")  
print("均方误差:", mse_knn)  
print("R^2 得分:", r2_knn)
#未完待续，如有帮助，恭请采纳

Answer 4

可以参考下

#include<iostream>
#include<iomanip>
#include<vector>
#include<set>
#include<stack>
using namespace std;
class WF{
    public:
    string *VN;     //非终结符集
    string *VT;     //终结符集
    string *P;      //产生式集
    string S;       //开始符号
    string Token;   //待分析串
    string *head;   //存储产生式->的左半部分
    vector<string> *tail;//存储产生式->的右半部分
    set<string> *first; //用以存储First集
    set<string> *follow;//用以存储Follow集
    int length[3];      //记录VN，VT，P的长度
    set<string>::iterator tt;//用作iterator读取set集合内容
    int **M;//二维数组，可以用存储预测分析表的内容，
    //某位置没有产生式标记为-1，否则标记为产生式的序列号
    void init(){
        //init函数用于初始化
        char ch;
        string token;
        cin>>length[0];              //获得非终结符符集数目
        M=new int *[length[0]];
        VN=new string[length[0]];
        head=new string[length[2]];
        tail=new vector<string>[length[2]];
        first=new set<string>[length[0]];
        follow=new set<string>[length[0]];
        for(int i=0;i<length[0];i++)
            cin>>VN[i];
        cin>>length[1];              //获得终结符符集数目
        for(int i=0;i<length[0];i++)
            M[i]=new int[length[1]+1];
        VT=new string[length[1]+1];
        for(int i=0;i<length[1];i++)
            cin>> VT[i];
        VT[length[1]]="ε";
        cin>>length[2];              //获得产生式集数目
        P=new string[length[2]];
        getline(cin,P[0]);           //跳转到下一行
        for(int i=0;i<length[2];i++){
            getline(cin,P[i]);
            head[i]=P[i].substr(0,P[i].find(" "));
            for(int j=P[i].find(" ")+4;j<P[i].size();j++){
                if(P[i][j]==' '){
                    tail[i].push_back(token);
                    token.clear();
                    continue;
                } 
                else{
                    token+=P[i][j];
                }
            }
            if(!token.empty())
                tail[i].push_back(token);
            token.clear();             
        }
        cin>>S;                     //获得开始符号 
        cin>>Token;             //获得待分析串
    }
    void getFirstSet(){
        //求解其Frist集
        int k,l;
        int firstSetLength[length[0]];
        bool flag=true;
        for(int i=0;i<length[0];i++){
            for(int j=0;j<length[2];j++){
                if(!VN[i].compare(head[j])){
                    if(isVT(tail[j][0])){
                        //cout<<tail[j][0]<<endl;
                        first[i].insert(tail[j][0]); 
                    }
                }    
            }
        }
        for(int i=0;i<length[0];i++){
            firstSetLength[i]=first[i].size();
        }
        //保存初始长度
        do{ 
            flag=false;
            for(int i=0;i<length[0];i++){//遍历VN
                for(int j=0;j<length[2];j++){//遍历产生式
                    if(!VN[i].compare(head[j])){//遇到VN对应产生式
                        k=0,l=0;
                        while(k<tail[j].size()&&!isVT(tail[j][k])){
                            for(int loc=0;loc<length[0];loc++)
                                if(!tail[j][k].compare(VN[loc])){
                                    for(tt=first[loc].begin();tt!=first[loc].end();tt++)
                                //添加LOC所定位的非终结符对应的First集\ε
                                        if(!(*tt).compare("ε"))
                                            k++;
                                        else
                                            first[i].insert(*tt);
                                break;
                                } 
                            if(k>l) l=k;//当前VN的的first集含有ε，继续添加下一个
                            else break;    
                        }
                        if(k==tail[j].size()) first[i].insert("ε");
                        //对于所有Yi都含有ε的，添加ε到first集
                        else if(isVT(tail[j][k])){
                            //添加可以推导出ε部分临近的终结符
                            first[i].insert(tail[j][k]);
                        }
                            
                    }    
                }
            }
            for(int i=0;i<length[0];i++){
                if(firstSetLength[i]!=first[i].size()){
                    firstSetLength[i]=first[i].size();
                    flag=true;
                }
        }
        }while(flag);//保证各个Frist集不再发生变化  
    }
    void getFollowSet(){
        //求解其Follow集
        set<string> temp;
        int l,h;
        int followSetLength[length[0]];
        bool flag;
        for(int i=0;i<length[0];i++)
            if(!VN[i].compare(S)){
                follow[i].insert("#");
                break;
            }
        for(int i=0;i<length[0];i++){
            followSetLength[i]=follow[i].size();
        }
        //保存每个Follow集的长度
        do{
            flag=false;
            for(int i=0;i<length[0];i++)
                for(int j=0;j<length[2];j++)
                    for(int k=0;k<tail[j].size();k++){
                        temp.clear();
                        if(!isVT(tail[j][k])){
                            if((k+1)==tail[j].size()){
                                int loc=locVN(head[j]);
                                for(tt=follow[loc].begin();tt!=follow[loc].end();tt++){
                                    temp.insert(*tt);
                                }    
                            }else if(isVT(tail[j][k+1])){
                                temp.insert(tail[j][k+1]);
                                
                            }else {
                                l=k+1;
                                h=k+1;
                                while(h<tail[j].size()&&!isVT(tail[j][h])){
                                    int loc=locVN(tail[j][l]);
                                    for(tt=first[loc].begin();tt!=first[loc].end();tt++){
                                        if(!(*tt).compare("ε"))
                                            h++;
                                        else{
                                            temp.insert(*tt);
                                        }
                                            
                                    }
                                    if(h>l) l=h;
                                    else break;  
                                }
                                if(h==tail[j].size()) {
                                    int loc=locVN(head[j]);
                                    for(tt=follow[loc].begin();tt!=follow[loc].end();tt++)
                                        temp.insert(*tt);
                                 }else if(isVT(tail[j][h])){
                                    temp.insert(tail[j][h]);
                                }
                                    
                            }
                        }
                        for(tt=temp.begin();tt!=temp.end();tt++){
                            follow[locVN(tail[j][k])].insert(*tt);
                        }       
                    }
                    for(int i=0;i<length[0];i++)
                        if(followSetLength[i]!=follow[i].size()){
                            followSetLength[i]=follow[i].size();
                            flag=true;
                        }          
        }while(flag);//当Follow集长度不在发生变化时，求解完毕，跳出该循环 
    }
    void printPredictionAnalysisTable(){
        //对M初始化并输出预测分析表
        set<string> temp[length[2]];
        int i,j;
        bool flag;
        for(i=0;i<length[0];i++)
            for(j=0;j<=length[1];j++)
                M[i][j]=-1;//为预测分析表中的状态进行初始化，-1代表
        for(i=0;i<length[2];i++){
            flag=false;
            for(j=0;j<tail[i].size();j++){
                if(isVT(tail[i][j])){
                    temp[i].insert(tail[i][j]);
                    break;
                }else{
                    int loc=locVN(tail[i][j]);
                    for(tt=first[loc].begin();tt!=first[loc].end();tt++)
                        if((*tt).compare("ε"))
                            temp[i].insert(*tt);
                        else
                            flag=true;//表明当前添加的First集中含有ε，可以继续向下进行
                }
                if(!flag) break;
            }
            if(j==tail[i].size())
                temp[i].insert("ε");
        }
        for(i=0;i<length[0];i++)
            for(j=0;j<length[1];j++)
                for(int loc=0;loc<length[2];loc++)
                    if(!head[loc].compare(VN[i])&&temp[loc].count(VT[j]))
                        M[i][j]=loc;
        for(int loc=0;loc<length[2];loc++)
            if(temp[loc].count("ε")){
                int k=locVN(head[loc]);//获得VN下标
                for(tt=follow[k].begin();tt!=follow[k].end();tt++){
                    if(!(*tt).compare("#"))
                        M[k][length[1]]=loc;
                    else for(j=0;j<length[1];j++)
                        if(!VT[j].compare(*tt)){
                            M[k][j]=loc;
                            break;
                        }
                }
            }
        cout<<"预测分析表：\n"<<setw(8)<<left<<" ";
        for(i=0;i<length[1];i++)
            cout<<setw(6)<<left<<VT[i];
        cout<<"#\n";
        cout<<"-----+";
        for(i=0;i<=length[1];i++)
            cout<<"-----+";
        for(i=0;i<length[0];i++){
            cout<<"\n"<<setw(8)<<left<<VN[i];
            for(j=0;j<=length[1];j++){
                if(M[i][j]!=-1)
                    cout<<"P"<<setw(5)<<left<<M[i][j];
                else 
                    cout<<setw(6)<<left<<" ";
            }   
        }
        cout<<"\n-----+";
        for(i=0;i<=length[1];i++)
            cout<<"-----+";
    }
    void analyse(string token){
        //分析读取的待分析串
        stack<string> LL;
        vector<string> temp;
        string X;
        string a;
        int i=0;
        int step=1;
        int loc;
        bool flag=true;
        LL.push("#");
        LL.push(S);//#和开始符号均入栈
        token+='#';
        cout<<"\n\n"<<token<<"分析过程：\n";
        cout<<"\n初始化：#入栈，"<<S<<"入栈；";
        a.clear();
        a+=token[i];
        while(flag){
            X=LL.top();
            LL.pop();
            cout<<"\n"<<setfill('0')<<setw(3)<<right<<step<<":出栈X="<<X<<"，输入c="<<a<<"，";
            if(isVT(X)){
                if(!X.compare(a)){
                    step++;
                    cout<<"匹配，输入指针后移；\n";
                    a.clear();
                    a+=token[++i];
                }else{
                    cout<<"ERROR!!"<<endl;
                    break;
                }
                }else if(!X.compare("#")){
                    if(!X.compare(a)){
                        flag=false;//完成
                        cout<<"匹配，成功。"<<endl;
                        break;
                    }else{
                        cout<<"ERROR!!"<<endl;
                        break;
                    }
                }else if((loc=M[locVN(X)][locVT(a)])!=-1){
                    step++;
                    cout<<"查表，M[X,c]="<<X<<"->";
                    for(int j=0;j<tail[loc].size();j++){
                        cout<<tail[loc][j];
                    }
                        
                    cout<<"，产生式右部逆序入栈(ε不入栈)；\n";
                    for(int j=tail[loc].size();j;j--)
                        if(tail[loc][j-1].compare("ε"))
                            LL.push(tail[loc][j-1]); 
                }else{
                    cout<<"ERROR!!"<<endl;
                    break;
                }
            }
    }
    bool isVT(string str){
        //判断是否为VT，若是则返回true，否则返回false
        for(int i=0;i<length[1]+1;i++)
            if(!str.compare(VT[i]))
                return true;
        return false;
    }
    int locVN(string str){
        //返回VN的位置序号
        for(int i=0;i<length[0];i++)
            if(!str.compare(VN[i]))
                return i;
        return -1;
    }
    int locVT(string str){
        //返回VT的列位置序号，对于符号#返回其为最后一列的序号
        for(int i=0;i<length[1];i++)
            if(!str.compare(VT[i]))
                return i;
        if(!str.compare("#"))
            return length[1];
        return -1;
    }
    };
int main(){
    //实验6程序，输入文件请采用ANSI编码格式，否则无法正常读取！！！！！！
    WF G;
    G.init();
    //文法初始化
    G.getFirstSet();
    //获得First集
    G.getFollowSet();
    //获得Follow集
    G.printPredictionAnalysisTable();
    //构建并输出预测分析表
    G.analyse(G.Token);
    //输出对G.Token的分析
    system("pause");
    return 0;
}