🚀 AI FRONTIER
2026年Python+AI学习路线完整指南：从零基础到实战专家
2026年03月07日 18时 · 来源：CSDN
Python已成为人工智能领域最主流的编程语言，根据Stack Overflow 2024年开发者调查，Python在AI/ML领域的使用率超过85%。
Python已成为人工智能领域最主流的编程语言，根据Stack Overflow 2024年开发者调查，Python在AI/ML领域的使用率超过85%。
了解AI各领域的占比，帮助你更好地规划学习重点：
下图展示了从零基础到AI专家的完整学习路线：
🟢 阶段0：Python基础（2-4周）
学习目标：掌握Python核心语法和编程思维
list, dict, tuple, set
# 传统方式squares=[]foriinrange(10):squares.append(i**2)# Pythonic方式squares=[i**2foriinrange(10)]# 带条件的列表推导式even_squares=[i**2foriinrange(10)ifi%2==0]print(even_squares)# [0, 4, 16, 36, 64]
# 字典推导式word_count="hello world hello python"counts={word:word_count.split().count(word)forwordinset(word_count.split())}print(counts)# {'hello': 2, 'world': 1, 'python': 1}# defaultdict使用fromcollectionsimportdefaultdict counts=defaultdict(int)forwordinword_count.split():counts[word]+=1
# 正确的文件操作方式withopen('data.txt','r',encoding='utf-8')asf:content=f.read()# 自动关闭文件，即使发生异常# 自定义上下文管理器fromcontextlibimportcontextmanager@contextmanagerdeftimer():importtime start=time.time()yieldprint(f"耗时:{time.time()-start:.2f}秒")withtimer():sum(range(1000000))
🔵 阶段1：数据科学基础（4-6周）
学习目标：掌握数据处理、分析和可视化技能
importnumpyasnp# 数组创建arr=np.array([[1,2,3],[4,5,6]])zeros=np.zeros((3,4))random=np.random.randn(3,3)# 数组运算print(arr*2)# 元素级乘法print(arr @ arr.T)# 矩阵乘法print(np.dot(arr,arr.T))# 矩阵乘法# 广播机制a=np.array([[1,2,3],[4,5,6]])# (2, 3)b=np.array([10,20,30])# (3,)print(a+b)# b广播到(2, 3)# 实用函数print(np.mean(arr,axis=1))# 按行求均值print(np.argmax(arr,axis=1))# 按行找最大值索引
importpandasaspd# 创建DataFramedata={'name':['张三','李四','王五','赵六'],'age':[25,30,35,28],'city':['北京','上海','深圳','杭州'],'salary':[15000,20000,25000,18000]}df=pd.DataFrame(data)# 数据筛选high_salary=df[df['salary']>18000]beijing=df[df['city']=='北京']# 数据分组city_stats=df.groupby('city').agg({'salary':['mean','max','count']})# 数据排序df_sorted=df.sort_values('salary',ascending=False)# 数据合并df2=pd.DataFrame({'name':['张三','李四'],'department':['技术','产品']})merged=pd.merge(df,df2,on='name',how='left')print(city_stats)
importmatplotlib.pyplotaspltimportseabornassns# 设置中文字体plt.rcParams['font.sans-serif']=['SimHei']plt.rcParams['axes.unicode_minus']=False# 创建子图fig,axes=plt.subplots(2,2,figsize=(12,10))# 1. 柱状图axes[0,0].bar(df['name'],df['salary'])axes[0,0].set_title('薪资对比')axes[0,0].set_xlabel('姓名')axes[0,0].set_ylabel('薪资')# 2. 散点图axes[0,1].scatter(df['age'],df['salary'],s=100,alpha=0.6)axes[0,1].set_title('年龄与薪资关系')axes[0,1].set_xlabel('年龄')axes[0,1].set_ylabel('薪资')# 3. 饼图（城市分布）city_counts=df['city'].value_counts()axes[1,0].pie(city_counts,labels=city_counts.index,autopct='%1.1f%%')axes[1,0].set_title('城市分布')# 4. 箱线图axes[1,1].boxplot(df['salary'])axes[1,1].set_title('薪资分布')plt.tight_layout()plt.savefig('visualization.png',dpi=300)plt.show()
🟡 阶段2：机器学习（6-8周）
学习目标：理解ML原理，掌握Scikit-learn实战
importnumpyasnpimportpandasaspdimportmatplotlib.pyplotaspltfromsklearn.model_selectionimporttrain_test_splitfromsklearn.linear_modelimportLinearRegressionfromsklearn.metricsimportmean_squared_error,r2_scorefromsklearn.preprocessingimportStandardScaler# 生成模拟数据np.random.seed(42)n_samples=1000# 特征：面积、房间数、房龄X=np.random.randn(n_samples,3)X[:,0]=X[:,0]*50+100# 面积：50-150㎡X[:,1]=np.abs(X[:,1])*2+1# 房间数：1-5间X[:,2]=np.abs(X[:,2])*10+1# 房龄：1-30年# 真实价格 = 面积*1000 + 房间数*50000 - 房龄*2000 + 噪声y=(X[:,0]*1000+X[:,1]*50000-X[:,2]*2000+np.random.randn(n_samples)*50000)# 划分数据集X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.2,random_state=42)# 特征标准化scaler=StandardScaler()X_train_scaled=scaler.fit_transform(X_train)X_test_scaled=scaler.transform(X_test)# 训练模型model=LinearRegression()model.fit(X_train_scaled,y_train)# 预测y_pred=model.predict(X_test_scaled)# 评估mse=mean_squared_error(y_test,y_pred)r2=r2_score(y_test,y_pred)print(f"均方误差 MSE:{mse:.2f}")print(f"决定系数 R²:{r2:.4f}")print(f"系数:{model.coef_}")print(f"截距:{model.intercept_:.2f}")# 可视化预测结果plt.figure(figsize=(10,6))plt.scatter(y_test,y_pred,alpha=0.5)plt.plot([y.min(),y.max()],[y.min(),y.max()],'r--',lw=2)plt.xlabel('真实价格')plt.ylabel('预测价格')plt.title('房价预测：真实值 vs 预测值')plt.grid(True,alpha=0.3)plt.show()
fromsklearn.datasetsimportmake_classificationfromsklearn.model_selectionimportcross_val_scorefromsklearn.linear_modelimportLogisticRegressionfromsklearn.svmimportSVCfromsklearn.treeimportDecisionTreeClassifierfromsklearn.ensembleimportRandomForestClassifierfromsklearn.naive_bayesimportGaussianNBfromsklearn.neighborsimportKNeighborsClassifier# 生成分类数据X,y=make_classification(n_samples=1000,n_features=20,n_informative=15,n_redundant=5,n_classes=3,random_state=42)# 定义模型models={'逻辑回归':LogisticRegression(max_iter=1000),'SVM':SVC(),'决策树':DecisionTreeClassifier(),'随机森林':RandomForestClassifier(n_estimators=100),'朴素贝叶斯':GaussianNB(),'KNN':KNeighborsClassifier()}# 交叉验证评估results={}forname,modelinmodels.items():scores=cross_val_score(model,X,y,cv=5,scoring='accuracy')results[name]={'mean':scores.mean(),'std':scores.std()}print(f"{name}:{scores.mean():.4f}(+/-{scores.std():.4f})")# 可视化对比plt.figure(figsize=(12,6))names=list(results.keys())means=[results[name]['mean']fornameinnames]stds=[results[name]['std']fornameinnames]plt.bar(names,means,yerr=stds,alpha=0.8,capsize=5)plt.ylabel('准确率')plt.title('不同分类算法性能对比（5折交叉验证）')plt.ylim(0.7,1.0)plt.grid(axis='y',alpha=0.3)plt.xticks(rotation=15)plt.show()
fromsklearn.clusterimportKMeans,DBSCANfromsklearn.datasetsimportmake_blobsfromsklearn.metricsimportsilhouette_score# 生成聚类数据X,_=make_blobs(n_samples=500,centers=4,cluster_std=1.5,random_state=42)# K-Means聚类（需要指定簇数）kmeans=KMeans(n_clusters=4,random_state=42,n_init=10)kmeans_labels=kmeans.fit_predict(X)kmeans_silhouette=silhouette_score(X,kmeans_labels)# DBSCAN聚类（自动发现簇数）dbscan=DBSCAN(eps=1.5,min_samples=10)dbscan_labels=dbscan.fit_predict(X)n_clusters=len(set(dbscan_labels))-(1if-1indbscan_labelselse0)print(f"K-Means: 发现4个簇, 轮廓系数={kmeans_silhouette:.3f}")print(f"DBSCAN: 发现{n_clusters}个簇")# 肘部法则确定最佳K值inertias=[]K_range=range(2,11)forKinK_range:kmeans=KMeans(n_clusters=K,random_state=42,n_init=10)kmeans.fit(X)inertias.append(kmeans.inertia_)plt.figure(figsize=(12,5))# 肘部图plt.subplot(1,2,1)plt.plot(K_range,inertias,'bo-')plt.xlabel('K值')plt.ylabel('惯性（Inertia）')plt.title('肘部法则确定最佳K值')plt.grid(True,alpha=0.3)# 聚类结果可视化plt.subplot(1,2,2)plt.scatter(X[:,0],X[:,1],c=kmeans_labels,cmap='viridis',alpha=0.6)plt.scatter(kmeans.cluster_centers_[:,0],kmeans.cluster_centers_[:,1],c='red',s=200,marker='X',label='质心')plt.title('K-Means聚类结果')plt.legend()plt.tight_layout()plt.show()
🟠 阶段3：深度学习（8-12周）
学习目标：掌握PyTorch，理解深度学习原理
importtorchimporttorch.nnasnnimporttorch.optimasoptimfromtorch.utils.dataimportDataLoader,TensorDatasetimportmatplotlib.pyplotasplt# 检查CUDA可用性device=torch.device('cuda'iftorch.cuda.is_available()else'cpu')print(f"使用设备:{device}")# 定义神经网络classNeuralNetwork(nn.Module):def__init__(self,input_size,hidden_size,num_classes):super(NeuralNetwork,self).__init__()self.layer1=nn.Linear(input_size,hidden_size)self.relu=nn.ReLU()self.layer2=nn.Linear(hidden_size,hidden_size//2)self.layer3=nn.Linear(hidden_size//2,num_classes)self.dropout=nn.Dropout(0.2)defforward(self,x):out=self.layer1(x)out=self.relu(out)out=self.dropout(out)out=self.layer2(out)out=self.relu(out)out=self.dropout(out)out=self.layer3(out)returnout# 超参数input_size=784# MNIST图像28x28hidden_size=256num_classes=10num_epochs=10batch_size=100learning_rate=0.001# 初始化模型model=NeuralNetwork(input_size,hidden_size,num_classes).to(device)# 损失函数和优化器criterion=nn.CrossEntropyLoss()optimizer=optim.Adam(model.parameters(),lr=learning_rate)# 模拟数据X_train=torch.randn(1000,input_size).to(device)y_train=torch.randint(0,num_classes,(1000,)).to(device)train_dataset=TensorDataset(X_train,y_train)train_loader=DataLoader(train_dataset,batch_size=batch_size,shuffle=True)# 训练循环train_losses=[]forepochinrange(num_epochs):model.train()epoch_loss=0fori,(images,labels)inenumerate(train_loader):# 前向传播outputs=model(images)loss=criterion(outputs,labels)# 反向传播和优化optimizer.zero_grad()loss.backward()optimizer.step()epoch_loss+=loss.item()avg_loss=epoch_loss/len(train_loader)train_losses.append(avg_loss)print(f'Epoch [{epoch+1}/{num_epochs}], Loss:{avg_loss:.4f}')# 绘制训练曲线plt.figure(figsize=(10,5))plt.plot(train_losses,marker='o')plt.xlabel('Epoch')plt.ylabel('Loss')plt.title('训练损失曲线')plt.grid(True,alpha=0.3)plt.show()
importtorchimporttorch.nnasnnimporttorch.nn.functionalasFclassCNN(nn.Module):def__init__(self,num_classes=10):super(CNN,self).__init__()# 第一个卷积块self.conv1=nn.Conv2d(1,32,kernel_size=3,padding=1)self.bn1=nn.BatchNorm2d(32)self.conv2=nn.Conv2d(32,32,kernel_size=3,padding=1)self.bn2=nn.BatchNorm2d(32)self.pool1=nn.MaxPool2d(2,2)# 第二个卷积块self.conv3=nn.Conv2d(32,64,kernel_size=3,padding=1)self.bn3=nn.BatchNorm2d(64)self.conv4=nn.Conv2d(64,64,kernel_size=3,padding=1)self.bn4=nn.BatchNorm2d(64)self.pool2=nn.MaxPool2d(2,2)# 全连接层self.fc1=nn.Linear(64*7*7,256)self.dropout=nn.Dropout(0.5)self.fc2=nn.Linear(256,num_classes)defforward(self,x):# 第一个卷积块x=F.relu(self.bn1(self.conv1(x)))x=F.relu(self.bn2(self.conv2(x)))x=self.pool1(x)# 第二个卷积块x=F.relu(self.bn3(self.conv3(x)))x=F.relu(self.bn4(self.conv4(x)))x=self.pool2(x)# 展平x=x.view(-1,64*7*7)# 全连接层x=F.relu(self.fc1(x))x=self.dropout(x)x=self.fc2(x)returnx# 模型结构可视化model=CNN()print(model)# 统计参数量total_params=sum(p.numel()forpinmodel.parameters())trainable_params=sum(p.numel()forpinmodel.parameters()ifp.requires_grad)print(f"总参数量:{total_params:,}")print(f"可训练参数量:{trainable_params:,}")
3. Transformer注意力机制
importtorchimporttorch.nnasnnimportmathclassMultiHeadAttention(nn.Module):def__init__(self,d_model,num_heads):super(MultiHeadAttention,self).__init__()assertd_model%num_heads==0self.d_model=d_model self.num_heads=num_heads self.d_k=d_model//num_heads self.W_q=nn.Linear(d_model,d_model)self.W_k=nn.Linear(d_model,d_model)self.W_v=nn.Linear(d_model,d_model)self.W_o=nn.Linear(d_model,d_model)defscaled_dot_product_attention(self,Q,K,V,mask=None):scores=torch.matmul(Q,K.transpose(-2,-1))/math.sqrt(self.d_k)ifmaskisnotNone:scores=scores.masked_fill(mask==0,-1e9)attention_weights=F.softmax(scores,dim=-1)output=torch.matmul(attention_weights,V)returnoutput,attention_weightsdefforward(self,query,key,value,mask=None):batch_size=query.size(0)# 线性变换并分割成多头Q=self.W_q(query).view(batch_size,-1,self.num_heads,self.d_k).transpose(1,2)K=self.W_k(key).view(batch_size,-1,self.num_heads,self.d_k).transpose(1,2)V=self.W_v(value).view(batch_size,-1,self.num_heads,self.d_k).transpose(1,2)# 计算注意力x,attention_weights=self.scaled_dot_product_attention(Q,K,V,mask)# 拼接多头x=x.transpose(1,2).contiguous().view(batch_size,-1,self.d_model)# 最终线性变换output=self.W_o(x)returnoutput,attention_weights# 使用示例d_model=512num_heads=8seq_length=10batch_size=4# 创建模拟输入x=torch.randn(batch_size,seq_length,d_model)# 创建注意力层mha=MultiHeadAttention(d_model,num_heads)output,attention=mha(x,x,x)print(f"输入形状:{x.shape}")print(f"输出形状:{output.shape}")print(f"注意力权重形状:{attention.shape}")
🔴 阶段4：NLP与LLM应用（6-8周）
学习目标：掌握现代NLP技术，熟练使用大语言模型
2023GPT-4/Llama2
fromtransformersimportpipeline,AutoTokenizer,AutoModelForSequenceClassificationimporttorch# 情感分析sentiment_pipeline=pipeline("sentiment-analysis",model="distilbert-base-uncased-finetuned-sst-2-english")texts=["I love this product! It's amazing!","This is the worst experience ever.","It's okay, nothing special."]results=sentiment_pipeline(texts)fortext,resultinzip(texts,results):print(f"文本:{text}")print(f"情感:{result['label']}, 置信度:{result['score']:.4f}\n")# 文本分类tokenizer=AutoTokenizer.from_pretrained("bert-base-chinese")model=AutoModelForSequenceClassification.from_pretrained("bert-base-chinese",num_labels=3# 正面、中性、负面)# 编码文本text="这家餐厅的菜品味道很好，服务也很周到！"inputs=tokenizer(text,return_tensors="pt",padding=True,truncation=True)# 预测withtorch.no_grad():outputs=model(**inputs)predictions=torch.nn.functional.softmax(outputs.logits,dim=-1)predicted_class=torch.argmax(predictions).item()labels=["负面","中性","正面"]print(f"预测类别:{labels[predicted_class]}")print(f"置信度:{predictions[0][predicted_class]:.4f}")
fromlangchain.document_loadersimportTextLoaderfromlangchain.text_splitterimportRecursiveCharacterTextSplitterfromlangchain.embeddingsimportHuggingFaceEmbeddingsfromlangchain.vectorstoresimportFAISSfromlangchain.chainsimportRetrievalQAfromlangchain.llmsimportOpenAIfromlangchain.promptsimportPromptTemplate# 1. 加载文档loader=TextLoader('knowledge_base.txt')documents=loader.load()# 2. 文本切分text_splitter=RecursiveCharacterTextSplitter(chunk_size=500,chunk_overlap=50,length_function=len)splits=text_splitter.split_documents(documents)# 3. 创建向量存储embeddings=HuggingFaceEmbeddings(model_name="sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2")vectorstore=FAISS.from_documents(splits,embeddings)# 4. 创建检索器retriever=vectorstore.as_retriever(search_type="similarity",search_kwargs={"k":3})# 5. 自定义提示模板prompt_template="""使用以下上下文信息来回答问题。如果不知道答案，就说不知道，不要编造答案。 上下文信息: {context} 问题: {question} 答案:"""PROMPT=PromptTemplate(template=prompt_template,input_variables=["context","question"])# 6. 创建QA链qa_chain=RetrievalQA.from_chain_type(llm=OpenAI(temperature=0),chain_type="stuff",retriever=retriever,return_source_documents=True,chain_type_kwargs={"prompt":PROMPT})# 7. 查询query="如何办理社保卡？"result=qa_chain({"query":query})print(f"问题:{query}")print(f"答案:{result['result']}")print("\n参考文档:")fordocinresult['source_documents']:print(f"-{doc.page_content[:100]}...")
3. 简单的ChatGLM对话示例
fromtransformersimportAutoTokenizer,AutoModelimporttorch# 加载模型tokenizer=AutoTokenizer.from_pretrained("THUDM/chatglm3-6b",trust_remote_code=True)model=AutoModel.from_pretrained("THUDM/chatglm3-6b",trust_remote_code=True).half().cuda()model=model.eval()# 对话历史history=[]response="你好！我是智能助手小政，有什么可以帮助您的吗？"print(f"助手:{response}")whileTrue:user_input=input("\n用户: ")ifuser_input.lower()in['退出','exit','quit']:break# 添加政务系统人设system_prompt="你是一个政务服务大厅的智能引导员，名叫'小政'。"response,history=model.chat(tokenizer,f"{system_prompt}\n用户:{user_input}",history=history,max_length=2048,temperature=0.7)print(f"小政:{response}")history.append((user_input,response))
端到端项目示例：智能文档问答系统
# project_structure.txt""" 智能文档问答系统 │ ├── data/ # 数据目录 │ ├── documents/ # 原始文档 │ └── vectorstore/ # 向量存储 │ ├── src/ # 源代码 │ ├── config.py # 配置文件 │ ├── loader.py # 文档加载 │ ├── embeddings.py # 向量化 │ ├── retriever.py # 检索器 │ ├── generator.py # 生成器 │ └── api.py # API接口 │ ├── app.py # 主应用 ├── requirements.txt # 依赖 └── README.md # 说明文档 """# config.pyimportosfromdataclassesimportdataclassfromtypingimportOptional@dataclassclassConfig:# API密钥OPENAI_API_KEY:str=os.getenv("OPENAI_API_KEY","")# 模型配置EMBEDDING_MODEL:str="sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"LLM_MODEL:str="gpt-3.5-turbo"LLM_TEMPERATURE:float=0.7LLM_MAX_TOKENS:int=1000# 向量存储配置CHUNK_SIZE:int=500CHUNK_OVERLAP:int=50VECTOR_DB_PATH:str="data/vectorstore"# 检索配置TOP_K:int=3SIMILARITY_THRESHOLD:float=0.7# API配置API_HOST:str="0.0.0.0"API_PORT:int=8000# loader.pyfromtypingimportListfromlangchain.document_loadersimport(TextLoader,PyPDFLoader,DirectoryLoader)fromlangchain.text_splitterimportRecursiveCharacterTextSplitterfromlangchain.schemaimportDocumentclassDocumentLoader:def__init__(self,chunk_size:int=500,chunk_overlap:int=50):self.text_splitter=RecursiveCharacterTextSplitter(chunk_size=chunk_size,chunk_overlap=chunk_overlap,length_function=len,separators=["\n\n","\n","。","！","？",".","!","?"," ",""])defload_text(self,file_path:str)->List[Document]:"""加载文本文件"""loader=TextLoader(file_path,encoding='utf-8')documents=loader.load()returnself.text_splitter.split_documents(documents)defload_pdf(self,file_path:str)->List[Document]:"""加载PDF文件"""loader=PyPDFLoader(file_path)documents=loader.load()returnself.text_splitter.split_documents(documents)defload_directory(self,directory:str,glob:str="**/*.txt")->List[Document]:"""加载目录下的所有文档"""loader=DirectoryLoader(directory,glob=glob)documents=loader.load()returnself.text_splitter.split_documents(documents)# api.pyfromfastapiimportFastAPI,HTTPExceptionfrompydanticimportBaseModelfromtypingimportList,Optionalimportuvicorn app=FastAPI(title="智能文档问答系统",version="1.0.0")classQueryRequest(BaseModel):question:strtop_k:Optional[int]=3classQueryResponse(BaseModel):answer:strsources:List[str]confidence:float@app.get("/")asyncdefroot():return{"message":"智能文档问答系统API","version":"1.0.0","endpoints":{"/query":"POST - 问答接口","/health":"GET - 健康检查"}}@app.get("/health")asyncdefhealth_check():return{"status":"healthy"}@app.post("/query",response_model=QueryResponse)asyncdefquery(request:QueryRequest):try:# 这里调用实际的问答逻辑# result = qa_chain({"query": request.question})returnQueryResponse(answer="这是示例回答",sources=["来源1","来源2"],confidence=0.95)exceptExceptionase:raiseHTTPException(status_code=500,detail=str(e))if__name__=="__main__":uvicorn.run("api:app",host="0.0.0.0",port=8000,reload=True)
""" 项目：预测客户是否会购买理财产品 数据集：模拟银行客户数据 """importpandasaspdimportnumpyasnpimportmatplotlib.pyplotaspltimportseabornassnsfromsklearn.model_selectionimporttrain_test_split,cross_val_score,GridSearchCVfromsklearn.preprocessingimportStandardScaler,LabelEncoderfromsklearn.ensembleimportRandomForestClassifier,GradientBoostingClassifierfromsklearn.linear_modelimportLogisticRegressionfromsklearn.metricsimportclassification_report,confusion_matrix,roc_auc_score,roc_curvefromsklearn.pipelineimportPipelineimportwarnings warnings.filterwarnings('ignore')# 设置中文字体plt.rcParams['font.sans-serif']=['SimHei']plt.rcParams['axes.unicode_minus']=False# ========== 1. 数据生成 ==========np.random.seed(42)n_samples=5000data={'年龄':np.random.randint(18,70,n_samples),'收入':np.random.randint(3000,50000,n_samples),'存款':np.random.randint(0,1000000,n_samples),'债务':np.random.randint(0,500000,n_samples),'信用评分':np.random.randint(300,850,n_samples),'已购买产品数':np.random.randint(0,10,n_samples),'上次购买天数':np.random.randint(30,3650,n_samples),'职业':np.random.choice(['学生','上班族','个体户','退休','自由职业'],n_samples),'婚姻状况':np.random.choice(['单身','已婚','离异'],n_samples),'学历':np.random.choice(['高中','本科','硕士','博士'],n_samples),}df=pd.DataFrame(data)# 生成目标变量（基于特征组合）defcalc_purchase_prob(row):score=0if25<=row['年龄']<=55:score+=20ifrow['收入']>15000:score+=20ifrow['存款']>100000:score+=20ifrow['信用评分']>650:score+=15ifrow['职业']in['上班族','个体户']:score+=15returnmin(score+np.random.randint(-10,10),100)/100df['购买概率']=df.apply(calc_purchase_prob,axis=1)df['是否购买']=(df['购买概率']>0.5).astype(int)# ========== 2. 数据探索 ==========print("="*50)print("数据集基本信息")print("="*50)print(df.info())print("\n目标变量分布:")print(df['是否购买'].value_counts())print(f"购买率:{df['是否购买'].mean():.2%}")# 可视化fig,axes=plt.subplots(2,3,figsize=(15,10))# 年龄分布axes[0,0].hist(df[df['是否购买']==0]['年龄'],bins=30,alpha=0.5,label='未购买')axes[0,0].hist(df[df['是否购买']==1]['年龄'],bins=30,alpha=0.5,label='购买')axes[0,0].set_xlabel('年龄')axes[0,0].set_ylabel('人数')axes[0,0].legend()axes[0,0].set_title('年龄与购买关系')# 收入分布axes[0,1].hist(df[df['是否购买']==0]['收入'],bins=30,alpha=0.5,label='未购买')axes[0,1].hist(df[df['是否购买']==1]['收入'],bins=30,alpha=0.5,label='购买')axes[0,1].set_xlabel('收入')axes[0,1].legend()axes[0,1].set_title('收入与购买关系')# 信用评分分布axes[0,2].hist(df[df['是否购买']==0]['信用评分'],bins=30,alpha=0.5,label='未购买')axes[0,2].hist(df[df['是否购买']==1]['信用评分'],bins=30,alpha=0.5,label='购买')axes[0,2].set_xlabel('信用评分')axes[0,2].legend()axes[0,2].set_title('信用评分与购买关系')# 职业分布career_purchase=df.groupby('职业')['是否购买'].mean()axes[1,0].bar(career_purchase.index,career_purchase.values)axes[1,0].set_ylabel('购买率')axes[1,0].set_title('不同职业的购买率')# 学历分布edu_purchase=df.groupby('学历')['是否购买'].mean()axes[1,1].bar(edu_purchase.index,edu_purchase.values)axes[1,1].set_ylabel('购买率')axes[1,1].set_title('不同学历的购买率')# 相关性热图numeric_cols=['年龄','收入','存款','债务','信用评分','已购买产品数','上次购买天数','是否购买']correlation=df[numeric_cols].corr()sns.heatmap(correlation,annot=True,fmt='.2f',cmap='coolwarm',center=0,ax=axes[1,2])axes[1,2].set_title('特征相关性热图')plt.tight_layout()plt.savefig('data_exploration.png',dpi=300)plt.show()# ========== 3. 特征工程 ==========# 编码分类变量le=LabelEncoder()df['职业编码']=le.fit_transform(df['职业'])df['婚姻编码']=le.fit_transform(df['婚姻状况'])df['学历编码']=le.fit_transform(df['学历'])# 创建新特征df['债务收入比']=df['债务']/(df['收入']*12+1)df['存款收入比']=df['存款']/(df['收入']*12+1)df['净资产']=df['存款']-df['债务']# 选择特征feature_cols=['年龄','收入','存款','债务','信用评分','已购买产品数','上次购买天数','职业编码','婚姻编码','学历编码','债务收入比','存款收入比','净资产']X=df[feature_cols]y=df['是否购买']# 划分数据集X_train,X_test,y_train,y_test=train_test_split(X,y,test_size=0.2,random_state=42,stratify=y)# ========== 4. 模型训练与评估 ==========# 定义模型models={'逻辑回归':Pipeline([('scaler',StandardScaler()),('model',LogisticRegression(max_iter=1000,random_state=42))]),'随机森林':RandomForestClassifier(n_estimators=100,random_state=42),'梯度提升':GradientBoostingClassifier(random_state=42)}# 训练和评估results={}forname,modelinmodels.items():print(f"\n训练{name}...")model.fit(X_train,y_train)# 预测y_pred=model.predict(X_test)y_pred_proba=model.predict_proba(X_test)[:,1]# 评估results[name]={'model':model,'predictions':y_pred,'probabilities':y_pred_proba,'accuracy':model.score(X_test,y_test),'roc_auc':roc_auc_score(y_test,y_pred_proba)}print(f"准确率:{results[name]['accuracy']:.4f}")print(f"AUC:{results[name]['roc_auc']:.4f}")# ========== 5. 最佳模型分析 ==========best_model_name=max(results,key=lambdax:results[x]['roc_auc'])best_model=results[best_model_name]['model']print(f"\n最佳模型:{best_model_name}")print("="*50)print("\n分类报告:")print(classification_report(y_test,results[best_model_name]['predictions']))# 混淆矩阵cm=confusion_matrix(y_test,results[best_model_name]['predictions'])plt.figure(figsize=(8,6))sns.heatmap(cm,annot=True,fmt='d',cmap='Blues')plt.xlabel('预测标签')plt.ylabel('真实标签')plt.title(f'{best_model_name}- 混淆矩阵')plt.show()# ROC曲线plt.figure(figsize=(10,6))forname,resultinresults.items():fpr,tpr,_=roc_curve(y_test,result['probabilities'])plt.plot(fpr,tpr,label=f"{name}(AUC ={result['roc_auc']:.3f})")plt.plot([0,1],[0,1],'k--',label='随机分类器')plt.xlabel('假正率')plt.ylabel('真正率')plt.title('ROC曲线对比')plt.legend()plt.grid(alpha=0.3)plt.show()# 特征重要性（树模型）ifhasattr(best_model,'feature_importances_'):feature_importance=pd.DataFrame({'feature':feature_cols,'importance':best_model.feature_importances_}).sort_values('importance',ascending=False)plt.figure(figsize=(10,6))plt.barh(feature_importance['feature'],feature_importance['importance'])plt.xlabel('重要性')plt.title('特征重要性')plt.tight_layout()plt.show()print("\n特征重要性排序:")print(feature_importance)print("\n"+"="*50)print("项目完成！")print("="*50)
┌─────────────────────────────────────────────────────┐ │ Python编程 │ │ - 《Python编程：从入门到实践》 │ │ - 《流畅的Python》 │ │ │ │ 数据科学 │ │ - 《利用Python进行数据分析》 │ │ - 《Python数据科学手册》 │ │ │ │ 机器学习 │ │ - 《机器学习》（周志华） │ │ - 《统计学习方法》（李航） │ │ - 《西瓜书》 │ │ │ │ 深度学习 │ │ - 《深度学习》（花书） │ │ - 《动手学深度学习》 │ │ │ │ NLP与LLM │ │ - 《自然语言处理综论》 │ │ - 《注意力机制》 │ └─────────────────────────────────────────────────────┘
官方文档：Python官方文档NumPy文档Pandas文档PyTorch文档Transformers文档
学习平台：Kaggle- 数据科学竞赛Papers with Code- 论文与代码Hugging Face- 预训练模型GitHub- 开源项目
Papers with Code- 论文与代码
Hugging Face- 预训练模型
Q1: 没有编程基础，能学Python+AI吗？
答: 完全可以！Python是公认最适合初学者的语言。建议学习路径：
Q2: 数学基础不好，能学AI吗？
答: 可以，但需要补充必要的数学知识：
建议：边做项目边补数学，遇到不懂的再学。
关键：项目经验 > 理论知识，一定要做项目！
云平台：Google Colab（免费GPU）Kaggle Notebooks（免费）AutoDL（便宜）
Google Colab（免费GPU）
Kaggle Notebooks（免费）
优化技巧：# 减小batch sizebatch_size=16# 而不是64# 使用混合精度训练fromtorch.cuda.ampimportautocast,GradScaler scaler=GradScaler()# 梯度累积accumulation_steps=4
# 减小batch sizebatch_size=16# 而不是64# 使用混合精度训练fromtorch.cuda.ampimportautocast,GradScaler scaler=GradScaler()# 梯度累积accumulation_steps=4
模型压缩：量化（Quantization）剪枝（Pruning）知识蒸馏（Distillation）
量化（Quantization）
知识蒸馏（Distillation）
关注前沿：arXiv.org（论文预印本）Hugging Face（新模型）Twitter/X（大佬动态）
arXiv.org（论文预印本）
Hugging Face（新模型）
实践导向：每月做一个小项目参与Kaggle竞赛贡献开源项目
社区交流：加入技术Discord/微信群参加线下meetup写技术博客
循序渐进：不要急于求成，按阶段学习
项目驱动：理论结合实践，多做项目
持续学习：AI技术更新快，保持学习热情
社区参与：加入社区，与他人交流学习
定期复盘：总结经验，形成自己的知识体系
“学习Python+AI是一场马拉松，不是短跑。重要的是保持持续学习和实践，不要害怕犯错。每一个错误都是学习的机会。”
“学习Python+AI是一场马拉松，不是短跑。重要的是保持持续学习和实践，不要害怕犯错。每一个错误都是学习的机会。”
祝你学习顺利，早日成为AI工程师！🚀
# 1. 安装Anaconda（推荐）# 下载：https://www.anaconda.com/# 2. 创建虚拟环境conda create-nai_envpython=3.10# 3. 激活环境conda activate ai_env# 4. 安装核心库pipinstallnumpy pandas matplotlib seaborn pipinstallscikit-learn xgboost lightgbm pipinstalltorch torchvision torchaudio pipinstalltransformers langchain pipinstalljupyter lab# 5. 启动Jupyterjupyter lab
# Jupyter相关jupyter notebook# 启动notebookjupyter lab# 启动labjupyter nbconvert# 转换notebook格式# Git相关gitclone# 克隆仓库gitadd.# 添加更改gitcommit-m"msg"# 提交gitpush# 推送# Conda相关condaenvlist# 列出环境condainstall# 安装包condaenvremove-n# 删除环境
能用Matplotlib绘制图表
能使用Scikit-learn建模
理解CNN/RNN/Transformer
熟练使用Transformers
✍️ 坚持用清晰易懂的图解+可落地的代码，让每个知识点都简单直观！💡座右铭：“道路是曲折的，前途是光明的！”
✍️ 坚持用清晰易懂的图解+可落地的代码，让每个知识点都简单直观！
💡座右铭：“道路是曲折的，前途是光明的！”
💡座右铭：“道路是曲折的，前途是光明的！”
━━━━━━━━━━━━━━━
📌 来源：CSDN
⚠️ 本文内容转载自第三方平台，版权归原作者所有
内容由闪闪整理，仅供学习参考，侵删请联系
