一、安裝和使用
官網下載安裝Cursor，然後建立一個程式碼檔案。
Ctrl + K生成， Ctrl + L提問。
預設每小時30詞。
- # 1. Try generating with command K on a new line. Ask for a pytorch script of a feedforward neural network
- # 2. Then, select the outputted code and hit chat. Ask if there's a bug. Ask how to improve.
- # 3. Try selecting some code and hitting edit. Ask the bot to add residual layers.
- # 4. To try out cursor on your own projects, go to the file menu (top left) and open a folder.
有些包需要自行安裝，程式不一定一次透過執行，可提問。
二、測試
1. 乒乓球遊戲
請用python寫一個乒乓球遊戲。有如下要求：- 遊戲包含兩個參與者，一方是電腦，一方是玩家；電腦在介面左側，玩家在介面右側。- 遊戲介面上包含一個開始按鈕，點選開始按鈕後，遊戲才能開始。- 乒乓球接觸球拍和介面上下邊界時會反彈。- 玩家透過Up,Down鍵來控制球拍的上下運動，玩家按住對應的鍵，球拍會保持一個方向運動。- 電腦透過自動判斷乒乓球的位置來進行移動，儘可能的將乒乓球反彈。- 一方的球拍沒有接到球的時候，對方得1分，先得夠5分的一方獲勝，同時遊戲結束。- 遊戲結束後顯示獲勝的一方的角色：電腦或者玩家。
程式碼
# Import necessary modules import pygame import random # Initialize Pygame pygame.init() # Set up the game window WINDOW_WIDTH = 800 WINDOW_HEIGHT = 600 WINDOW = pygame.display.set_mode((WINDOW_WIDTH, WINDOW_HEIGHT)) pygame.display.set_caption("Ping Pong Game") # Set up the colors WHITE = (255, 255, 255) BLACK = (0, 0, 0) # Set up the fonts FONT = pygame.font.SysFont(None, 48) # Set up the ball BALL_RADIUS = 10 ball_x = WINDOW_WIDTH // 2 ball_y = WINDOW_HEIGHT // 2 ball_dx = 5 * random.choice([-1, 1]) ball_dy = 5 * random.choice([-1, 1]) # Set up the paddles PADDLE_WIDTH = 10 PADDLE_HEIGHT = 100 player_paddle_x = WINDOW_WIDTH - PADDLE_WIDTH - 10 player_paddle_y = WINDOW_HEIGHT // 2 - PADDLE_HEIGHT // 2 computer_paddle_x = 10 computer_paddle_y = WINDOW_HEIGHT // 2 - PADDLE_HEIGHT // 2 paddle_speed = 5 # Set up the scores player_score = 0 computer_score = 0 # Set up the game loop game_running = False game_ended = False clock = pygame.time.Clock() while not game_ended: # Handle events for event in pygame.event.get(): if event.type == pygame.QUIT: game_ended = True elif event.type == pygame.KEYDOWN: if event.key == pygame.K_SPACE: game_running = True elif event.type == pygame.KEYUP: if event.key == pygame.K_UP or event.key == pygame.K_DOWN: player_paddle_dy = 0 # Handle player input keys = pygame.key.get_pressed() if keys[pygame.K_UP]: player_paddle_dy = -paddle_speed elif keys[pygame.K_DOWN]: player_paddle_dy = paddle_speed else: player_paddle_dy = 0 # Move the paddles player_paddle_y += player_paddle_dy if player_paddle_y < 0: player_paddle_y = 0 elif player_paddle_y > WINDOW_HEIGHT - PADDLE_HEIGHT: player_paddle_y = WINDOW_HEIGHT - PADDLE_HEIGHT computer_paddle_y += ball_dy if computer_paddle_y < 0: computer_paddle_y = 0 elif computer_paddle_y > WINDOW_HEIGHT - PADDLE_HEIGHT: computer_paddle_y = WINDOW_HEIGHT - PADDLE_HEIGHT # Move the ball if game_running: ball_x += ball_dx ball_y += ball_dy # Check for collisions with the walls if ball_y < BALL_RADIUS or ball_y > WINDOW_HEIGHT - BALL_RADIUS: ball_dy *= -1 # Check for collisions with the paddles if ball_x < computer_paddle_x + PADDLE_WIDTH and \ computer_paddle_y < ball_y < computer_paddle_y + PADDLE_HEIGHT: ball_dx *= -1 elif ball_x > player_paddle_x and \ player_paddle_y < ball_y < player_paddle_y + PADDLE_HEIGHT: ball_dx *= -1 elif ball_x < 0: player_score += 1 game_running = False ball_x = WINDOW_WIDTH // 2 ball_y = WINDOW_HEIGHT // 2 ball_dx = 5 * random.choice([-1, 1]) ball_dy = 5 * random.choice([-1, 1]) elif ball_x > WINDOW_WIDTH: computer_score += 1 game_running = False ball_x = WINDOW_WIDTH // 2 ball_y = WINDOW_HEIGHT // 2 ball_dx = 5 * random.choice([-1, 1]) ball_dy = 5 * random.choice([-1, 1]) # Check for game over if player_score == 5 or computer_score == 5: game_running = False game_over_text = FONT.render("Game Over", True, WHITE) if player_score == 5: winner_text = FONT.render("Player Wins!", True, WHITE) else: winner_text = FONT.render("Computer Wins!", True, WHITE) # Draw the game WINDOW.fill(BLACK) if not game_running: start_text = FONT.render("Press Space to Start", True, WHITE) start_rect = start_text.get_rect(center=(WINDOW_WIDTH // 2, WINDOW_HEIGHT // 2)) WINDOW.blit(start_text, start_rect) pygame.draw.circle(WINDOW, WHITE, (ball_x, ball_y), BALL_RADIUS) pygame.draw.rect(WINDOW, WHITE, (player_paddle_x, player_paddle_y, PADDLE_WIDTH, PADDLE_HEIGHT)) pygame.draw.rect(WINDOW, WHITE, (computer_paddle_x, computer_paddle_y, PADDLE_WIDTH, PADDLE_HEIGHT)) player_score_text = FONT.render(str(player_score), True, WHITE) computer_score_text = FONT.render(str(computer_score), True, WHITE) score_rect = player_score_text.get_rect(midtop=(WINDOW_WIDTH // 2, 10)) WINDOW.blit(player_score_text, score_rect.move(-50, 0)) WINDOW.blit(computer_score_text, score_rect.move(50, 0)) if not game_running and (player_score > 0 or computer_score > 0): WINDOW.blit(game_over_text, game_over_text.get_rect(center=(WINDOW_WIDTH // 2, WINDOW_HEIGHT // 2 - 50))) WINDOW.blit(winner_text, winner_text.get_rect(center=(WINDOW_WIDTH // 2, WINDOW_HEIGHT // 2 + 50))) pygame.display.update() clock.tick(60) # Quit Pygame pygame.quit()
可以執行
2. 手寫數字識別
用Python寫一個基於MINIST資料集的手寫數字識別程式碼，並給出測試樣例
import numpy as np import tensorflow as tf from tensorflow.keras.datasets import mnist from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense # Load MNIST dataset (x_train, y_train), (x_test, y_test) = mnist.load_data() # Normalize pixel values to be between 0 and 1 x_train = x_train / 255.0 x_test = x_test / 255.0 # Reshape input data to have a single channel x_train = np.reshape(x_train, (x_train.shape[0], x_train.shape[1], x_train.shape[2], 1)) x_test = np.reshape(x_test, (x_test.shape[0], x_test.shape[1], x_test.shape[2], 1)) # Define LeNet model model = Sequential() model.add(Conv2D(filters=6, kernel_size=(5, 5), activation='relu', input_shape=(28, 28, 1))) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Conv2D(filters=16, kernel_size=(5, 5), activation='relu')) model.add(MaxPooling2D(pool_size=(2, 2))) model.add(Flatten()) model.add(Dense(units=120, activation='relu')) model.add(Dense(units=84, activation='relu')) model.add(Dense(units=10, activation='softmax')) # Compile model model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) # Train model model.fit(x_train, y_train, epochs=5, validation_data=(x_test, y_test)) # Visualize test example # Visualize test example import matplotlib.pyplot as plt image_index = 4444 plt.imshow(x_test[image_index].reshape(28, 28),cmap='Greys') plt.show() # Predict test example pred = model.predict(x_test[image_index].reshape(1, 28, 28, 1)) print('Predicted value:', pred.argmax())
3. 聚類
k-means： 用Python實現K-means演算法，並在iris資料集上進行測試，最後對結果進行視覺化
from sklearn.datasets import load_iris from sklearn.cluster import KMeans import matplotlib.pyplot as plt # load iris dataset iris = load_iris() X = iris.data # initialize KMeans model with 3 clusters kmeans = KMeans(n_clusters=3) # fit the model to the data kmeans.fit(X) # predict the clusters for each data point y_kmeans = kmeans.predict(X) # plot the clusters plt.scatter(X[:, 0], X[:, 1], c=y_kmeans, cmap='viridis') centers = kmeans.cluster_centers_ plt.scatter(centers[:, 0], centers[:, 1], c='black', s=200, alpha=0.5); plt.show()
GMM： 用numpy實現GMM演算法，給出測試樣例
# Welcome to Cursor import numpy as np import matplotlib.pyplot as plt from scipy.stats import multivariate_normal # Generate some random data np.random.seed(0) n_samples = 300 mean1 = [0, 0] cov1 = [[1, 0], [0, 1]] mean2 = [5, 5] cov2 = [[1, 0], [0, 1]] X = np.concatenate([np.random.multivariate_normal(mean1, cov1, int(n_samples/2)), np.random.multivariate_normal(mean2, cov2, int(n_samples/2))]) # Define the number of clusters and the tolerance for convergence n_clusters = 2 tolerance = 0.01 # Initialize the means, covariances, and mixing coefficients means = np.random.rand(n_clusters, X.shape[1]) covs = np.array([np.eye(X.shape[1])] * n_clusters) mixing_coeffs = np.ones(n_clusters) / n_clusters # Define the function to compute the responsibilities def compute_responsibilities(X, means, covs, mixing_coeffs): responsibilities = np.zeros((X.shape[0], len(mixing_coeffs))) for k in range(len(mixing_coeffs)): responsibilities[:, k] = mixing_coeffs[k] * multivariate_normal.pdf(X, means[k], covs[k]) responsibilities /= np.sum(responsibilities, axis=1, keepdims=True) return responsibilities # Define the function to update the means, covariances, and mixing coefficients def update_parameters(X, responsibilities): n_clusters = responsibilities.shape[1] n_samples = X.shape[0] means = np.zeros((n_clusters, X.shape[1])) covs = np.zeros((n_clusters, X.shape[1], X.shape[1])) mixing_coeffs = np.zeros(n_clusters) for k in range(n_clusters): nk = np.sum(responsibilities[:, k]) means[k] = np.sum(responsibilities[:, k].reshape(-1, 1) * X, axis=0) / nk covs[k] = np.dot((responsibilities[:, k].reshape(-1, 1) * (X - means[k])).T, (X - means[k])) / nk mixing_coeffs[k] = nk / n_samples return means, covs, mixing_coeffs # Run the EM algorithm log_likelihoods = [] for i in range(100): responsibilities = compute_responsibilities(X, means, covs, mixing_coeffs) means, covs, mixing_coeffs = update_parameters(X, responsibilities) log_likelihood = np.sum(np.log(np.sum(responsibilities, axis=1))) log_likelihoods.append(log_likelihood) if i > 0 and np.abs(log_likelihoods[-1] - log_likelihoods[-2]) < tolerance: break # Plot the data and the clusters plt.scatter(X[:, 0], X[:, 1], c=np.argmax(responsibilities, axis=1)) plt.show()
4. RNN
用分別用Pytorh和Numpy寫一個RNN網路，然後在一個1960年到2022年世界總人口樹的時序資料上對它們進行測試。要求：-對比Arima演算法-對資料進行視覺化-用1960年到2012年預測2013年到2022年，對預測結果視覺化
# PyTorch RNN network import torch import torch.nn as nn class RNN(nn.Module): def __init__(self, input_size, hidden_size, output_size): super(RNN, self).__init__() self.hidden_size = hidden_size self.i2h = nn.Linear(input_size + hidden_size, hidden_size) self.i2o = nn.Linear(input_size + hidden_size, output_size) self.softmax = nn.LogSoftmax(dim=1) def forward(self, input, hidden): combined = torch.cat((input, hidden), 1) hidden = self.i2h(combined) output = self.i2o(combined) output = self.softmax(output) return output, hidden def initHidden(self): return torch.zeros(1, self.hidden_size) # Numpy RNN network import numpy as np class NumpyRNN: def __init__(self, input_size, hidden_size, output_size): self.hidden_size = hidden_size self.Wxh = np.random.randn(hidden_size, input_size) * 0.01 self.Whh = np.random.randn(hidden_size, hidden_size) * 0.01 self.Why = np.random.randn(output_size, hidden_size) * 0.01 self.bh = np.zeros((hidden_size, 1)) self.by = np.zeros((output_size, 1)) def forward(self, inputs, hprev): xs, hs, ys, ps = {}, {}, {}, {} hs[-1] = np.copy(hprev) for t in range(len(inputs)): xs[t] = np.zeros((input_size, 1)) xs[t][inputs[t]] = 1 hs[t] = np.tanh(np.dot(self.Wxh, xs[t]) + np.dot(self.Whh, hs[t-1]) + self.bh) ys[t] = np.dot(self.Why, hs[t]) + self.by ps[t] = np.exp(ys[t]) / np.sum(np.exp(ys[t])) return ps, hs def initHidden(self): return np.zeros((self.hidden_size, 1)) # Testing on world population data import pandas as pd import matplotlib.pyplot as plt from statsmodels.tsa.arima_model import ARIMA # Load data data = pd.read_csv('world_population.csv', index_col=0) data.index = pd.to_datetime(data.index) # Train-test split train_data = data.loc['1960':'2012'] test_data = data.loc['2013':'2022'] # ARIMA model model = ARIMA(train_data, order=(1, 1, 1)) model_fit = model.fit(disp=0) arima_pred = model_fit.predict(start='2013', end='2022', dynamic=False) # PyTorch RNN model input_size = 1 hidden_size = 32 output_size = 1 pytorch_rnn = RNN(input_size, hidden_size, output_size) criterion = nn.MSELoss() optimizer = torch.optim.Adam(pytorch_rnn.parameters(), lr=0.01) # Train PyTorch RNN model for epoch in range(1000): hidden = pytorch_rnn.initHidden() optimizer.zero_grad() loss = 0 for i in range(len(train_data)-1): input_tensor = torch.tensor(train_data.iloc[i]) target_tensor = torch.tensor(train_data.iloc[i+1]) output, hidden = pytorch_rnn(input_tensor, hidden) loss += criterion(output, target_tensor) loss.backward() optimizer.step() # Test PyTorch RNN model pytorch_rnn.eval() pytorch_pred = [] hidden = pytorch_rnn.initHidden() for i in range(len(test_data)): input_tensor = torch.tensor(test_data.iloc[i]) output, hidden = pytorch_rnn(input_tensor, hidden) pytorch_pred.append(output.detach().numpy()[0][0]) # Numpy RNN model input_size = 1 hidden_size = 32 output_size = 1 numpy_rnn = NumpyRNN(input_size, hidden_size, output_size) # Train Numpy RNN model loss_fn = nn.MSELoss() learning_rate = 0.01 for epoch in range(1000): hprev = numpy_rnn.initHidden() loss = 0 for i in range(len(train_data)-1): x = np.array(train_data.iloc[i]) y = np.array(train_data.iloc[i+1]) ps, hprev = numpy_rnn.forward(x, hprev) loss += loss_fn(torch.tensor(ps[len(ps)-1]), torch.tensor(y)) # Backpropagation dWhy = np.dot((ps[len(ps)-1]-y), hprev.T) dby = ps[len(ps)-1]-y dhnext = np.dot(numpy_rnn.Why.T, ps[len(ps)-1]-y) dWxh, dWhh, dbh = np.zeros_like(numpy_rnn.Wxh), np.zeros_like(numpy_rnn.Whh), np.zeros_like(numpy_rnn.bh) for t in reversed(range(len(ps)-1)): dy = np.copy(ps[t]) dy[train_data.iloc[t+1]] -= 1 dWhy += np.dot(dy, hs[t].T) dby += dy dh = np.dot(numpy_rnn.Why.T, dy) + dhnext dhraw = (1 - hs[t] * hs[t]) * dh dbh += dhraw dWxh += np.dot(dhraw, xs[t].T) dWhh += np.dot(dhraw, hs[t-1].T) dhnext = np.dot(numpy_rnn.Whh.T, dhraw) for dparam in [dWxh, dWhh, dWhy, dbh, dby]: np.clip(dparam, -5, 5, out=dparam) numpy_rnn.Wxh -= learning_rate * dWxh numpy_rnn.Whh -= learning_rate * dWhh numpy_rnn.Why -= learning_rate * dWhy numpy_rnn.bh -= learning_rate * dbh numpy_rnn.by -= learning_rate * dby # Test Numpy RNN model numpy_pred = [] hprev = numpy_rnn.initHidden() for i in range(len(test_data)): x = np.array(test_data.iloc[i]) ps, hprev = numpy_rnn.forward(x, hprev) numpy_pred.append(ps[len(ps)-1].argmax()) # Visualize results plt.figure(figsize=(10,5)) plt.plot(train_data.index, train_data, label='Training data') plt.plot(test_data.index, test_data, label='True values') plt.plot(test_data.index, arima_pred, label='ARIMA') plt.plot(test_data.index, pytorch_pred, label='PyTorch RNN') plt.plot(test_data.index, numpy_pred, label='Numpy RNN') plt.legend() plt.show()
不知道對不對，訓練程式碼都給出了
5. 自注意力
用Pytorch實現自注意力網路，並進行測試
import torch import torch.nn as nn import torch.nn.functional as F class SelfAttention(nn.Module): def __init__(self, embed_size, heads): super(SelfAttention, self).__init__() self.embed_size = embed_size self.heads = heads self.head_dim = embed_size // heads assert (self.head_dim * heads == embed_size), "Embed size needs to be divisible by heads" self.values = nn.Linear(self.head_dim, self.head_dim, bias=False) self.keys = nn.Linear(self.head_dim, self.head_dim, bias=False) self.queries = nn.Linear(self.head_dim, self.head_dim, bias=False) self.fc_out = nn.Linear(heads*self.head_dim, embed_size) def forward(self, values, keys, query, mask): N = query.shape[0] value_len, key_len, query_len = values.shape[1], keys.shape[1], query.shape[1] # Split embedding into self.heads pieces values = values.reshape(N, value_len, self.heads, self.head_dim) keys = keys.reshape(N, key_len, self.heads, self.head_dim) query = query.reshape(N, query_len, self.heads, self.head_dim) values = self.values(values) # (N, value_len, heads, head_dim) keys = self.keys(keys) # (N, key_len, heads, head_dim) queries = self.queries(query) # (N, query_len, heads, head_dim) energy = torch.einsum("nqhd,nkhd->nhqk", [queries, keys]) # (N, heads, query_len, key_len) if mask is not None: energy = energy.masked_fill(mask == 0, float("-1e20")) attention = torch.softmax(energy / (self.embed_size ** (1/2)), dim=3) # (N, heads, query_len, key_len) out = torch.einsum("nhql,nlhd->nqhd", [attention, values]).reshape(N, query_len, self.heads*self.head_dim) out = self.fc_out(out) return out class TransformerBlock(nn.Module): def __init__(self, embed_size, heads, dropout, forward_expansion): super(TransformerBlock, self).__init__() self.attention = SelfAttention(embed_size, heads) self.norm1 = nn.LayerNorm(embed_size) self.norm2 = nn.LayerNorm(embed_size) self.feed_forward = nn.Sequential( nn.Linear(embed_size, forward_expansion*embed_size), nn.ReLU(), nn.Linear(forward_expansion*embed_size, embed_size) ) self.dropout = nn.Dropout(dropout) def forward(self, value, key, query, mask): attention = self.attention(value, key, query, mask) x = self.dropout(self.norm1(attention + query)) forward = self.feed_forward(x) out = self.dropout(self.norm2(forward + x)) return out class Encoder(nn.Module): def __init__(self, src_vocab_size, embed_size, num_layers, heads, device, forward_expansion, dropout, max_length): super(Encoder, self).__init__() self.embed_size = embed_size self.device = device self.word_embedding = nn.Embedding(src_vocab_size, embed_size) self.position_embedding = nn.Embedding(max_length, embed_size) self.layers = nn.ModuleList([ TransformerBlock(embed_size, heads, dropout=dropout, forward_expansion=forward_expansion) for _ in range(num_layers) ]) self.dropout = nn.Dropout(dropout) def forward(self, x, mask): N, seq_length = x.shape positions = torch.arange(0, seq_length).expand(N, seq_length).to(self.device) out = self.dropout(self.word_embedding(x) + self.position_embedding(positions)) for layer in self.layers: out = layer(out, out, out, mask) return out class DecoderBlock(nn.Module): def __init__(self, embed_size, heads, forward_expansion, dropout, device): super(DecoderBlock, self).__init__() self.norm = nn.LayerNorm(embed_size) self.attention = SelfAttention(embed_size, heads) self.transformer_block = TransformerBlock(embed_size, heads, dropout, forward_expansion) self.dropout = nn.Dropout(dropout) def forward(self, x, value, key, src_mask, trg_mask): attention = self.attention(x, x, x, trg_mask) query = self.dropout(self.norm(attention + x)) out = self.transformer_block(value, key, query, src_mask) return out class Decoder(nn.Module): def __init__(self, trg_vocab_size, embed_size, num_layers, heads, forward_expansion, dropout, device, max_length): super(Decoder, self).__init__() self.device = device self.word_embedding = nn.Embedding(trg_vocab_size, embed_size) self.position_embedding = nn.Embedding(max_length, embed_size) self.layers = nn.ModuleList([ DecoderBlock(embed_size, heads, forward_expansion, dropout, device) for _ in range(num_layers) ]) self.fc_out = nn.Linear(embed_size, trg_vocab_size) self.dropout = nn.Dropout(dropout) def forward(self, x, enc_out, src_mask, trg_mask): N, seq_length = x.shape positions = torch.arange(0, seq_length).expand(N, seq_length).to(self.device) x = self.dropout(self.word_embedding(x) + self.position_embedding(positions)) for layer in self.layers: x = layer(x, enc_out, enc_out, src_mask, trg_mask) out = self.fc_out(x) return out class Transformer(nn.Module): def __init__(self, src_vocab_size, trg_vocab_size, src_pad_idx, trg_pad_idx, embed_size=256, num_layers=6, forward_expansion=4, heads=8, dropout=0, device="cuda", max_length=100): super(Transformer, self).__init__() self.encoder = Encoder(src_vocab_size, embed_size, num_layers, heads, device, forward_expansion, dropout, max_length) self.decoder = Decoder(trg_vocab_size, embed_size, num_layers, heads, forward_expansion, dropout, device, max_length) self.src_pad_idx = src_pad_idx self.trg_pad_idx = trg_pad_idx self.device = device def make_src_mask(self, src): src_mask = (src != self.src_pad_idx).unsqueeze(1).unsqueeze(2) # (N, 1, 1, src_len) return src_mask.to(self.device) def make_trg_mask(self, trg): trg_mask = torch.tril(torch.ones((seq_length, seq_length))).expand(N, 1, seq_length, seq_length) # (N, 1, trg_len, trg_len) return trg_mask.to(self.device)
不知道對不對，寫到一般次數受限了（直接寫Transformer了）
6. 聊天
實現一個聊天機器人，給出測試樣例
# 使用Python呼叫BERT實現聊天機器人 import torch from transformers import BertTokenizer, BertForQuestionAnswering # 載入預訓練的BERT模型 tokenizer = BertTokenizer.from_pretrained('bert-base-chinese') model = BertForQuestionAnswering.from_pretrained('bert-base-chinese') # 回答問題的函式 def answer_question(question, answer_text): # 將問題和答案文字編碼為輸入ID input_ids = tokenizer.encode(question, answer_text) tokens = tokenizer.convert_ids_to_tokens(input_ids) # 確定問題和答案文字的分段ID sep_index = input_ids.index(tokenizer.sep_token_id) num_seg_a = sep_index + 1 num_seg_b = len(input_ids) - num_seg_a segment_ids = [0]*num_seg_a + [1]*num_seg_b assert len(segment_ids) == len(input_ids) # 使用BertForQuestionAnswering模型預測答案的開始和結束位置 outputs = model(torch.tensor([input_ids]), token_type_ids=torch.tensor([segment_ids])) start_scores = outputs.start_logits end_scores = outputs.end_logits # 找到具有最高“start”和“end”分數的標記 answer_start = torch.argmax(start_scores) answer_end = torch.argmax(end_scores) # 將標記轉換回字串 answer = tokens[answer_start] for i in range(answer_start + 1, answer_end + 1): if tokens[i][0:2] == '##': answer += tokens[i][2:] else: answer += ' ' + tokens[i] return answer
# Here is an example of how to use the answer_question function: question = "什麼是BERT？" answer_text = "BERT是一種預訓練語言模型，可以用於各種自然語言處理任務。" answer = answer_question(question, answer_text) print(answer) # Output: "一種預訓練語言模型"
解釋
BertForQuestionAnswering是一個預訓練的BERT模型，用於回答問題。它是transformers庫中的一個類，可以透過from_pretrained方法載入預訓練的模型。在給定問題和答案文字的情況下，answer_question函式使用BertTokenizer將文字編碼為輸入ID，並使用BertForQuestionAnswering模型預測答案的開始和結束位置。然後，它將這些位置轉換回標記並返回答案字串。
直接調包，好像沒理解問題，給出QA了。
7. 矩陣乘法
基於C++實現通用矩陣乘法，並給出多個測試樣例。要求如下：- 矩陣乘法需要實現分塊乘法- 需要根據矩陣的稀疏情況進行最佳化
#include <iostream> #include <vector> #include <algorithm> using namespace std; const int BLOCK_SIZE = 32; void gemm(vector<vector<double>>& A, vector<vector<double>>& B, vector<vector<double>>& C) { int n = A.size(), m = B.size(), p = B[0].size(); for (int i = 0; i < n; i += BLOCK_SIZE) { for (int j = 0; j < p; j += BLOCK_SIZE) { for (int k = 0; k < m; k += BLOCK_SIZE) { for (int ii = i; ii < min(n, i + BLOCK_SIZE); ii++) { for (int jj = j; jj < min(p, j + BLOCK_SIZE); jj++) { for (int kk = k; kk < min(m, k + BLOCK_SIZE); kk++) { C[ii][jj] += A[ii][kk] * B[kk][jj]; } } } } } } } void optimize_gemm(vector<vector<double>>& A, vector<vector<double>>& B, vector<vector<double>>& C) { int n = A.size(), m = B.size(), p = B[0].size(); vector<vector<double>> Bt(p, vector<double>(m)); for (int i = 0; i < p; i++) { for (int j = 0; j < m; j++) { Bt[i][j] = B[j][i]; } } for (int i = 0; i < n; i += BLOCK_SIZE) { for (int j = 0; j < p; j += BLOCK_SIZE) { for (int k = 0; k < m; k += BLOCK_SIZE) { for (int ii = i; ii < min(n, i + BLOCK_SIZE); ii++) { for (int jj = j; jj < min(p, j + BLOCK_SIZE); jj++) { double sum = 0; for (int kk = k; kk < min(m, k + BLOCK_SIZE); kk++) { sum += A[ii][kk] * Bt[jj][kk]; } C[ii][jj] += sum; } } } } } } int main() { vector<vector<double>> A = {{1, 2, 3}, {4, 5, 6}}; vector<vector<double>> B = {{7, 8}, {9, 10}, {11, 12}}; vector<vector<double>> C1(2, vector<double>(2)), C2(2, vector<double>(2)); gemm(A, B, C1); optimize_gemm(A, B, C2); cout << "C1:" << endl; for (auto row : C1) { for (auto x : row) { cout << x << " "; } cout << endl; } cout << "C2:" << endl; for (auto row : C2) { for (auto x : row) { cout << x << " "; } cout << endl; } return 0; }
可執行
用python寫一個基於多執行緒的並行矩陣乘法，並給出測試樣例
import numpy as np import threading # Define a function to perform matrix multiplication def matmul(A, B, C, i, j): C[i][j] = np.dot(A[i], B[:,j]) # Define a function to perform parallel matrix multiplication def parallel_matmul(A, B, num_threads): # Get the shape of the matrices m, n = A.shape p, q = B.shape # Check if the matrices can be multiplied if n != p: print("Matrices cannot be multiplied") return None # Create a matrix to store the result C = np.zeros((m, q)) # Create a list to store the threads threads = [] # Create the threads for i in range(m): for j in range(q): thread = threading.Thread(target=matmul, args=(A, B, C, i, j)) threads.append(thread) # Start the threads for i in range(num_threads): for j in range(i, len(threads), num_threads): threads[j].start() # Wait for the threads to finish for thread in threads: thread.join() # Return the result return C # Test the function A = np.array([[1, 2], [3, 4], [5, 6]]) B = np.array([[7, 8], [9, 10]]) C = parallel_matmul(A, B, 2) print(C)
可執行
8. 視覺化
獲取貴州茅臺從2018年元旦至2023年3月20日的行情資料，計算MACD指標
import tushare as ts import matplotlib.pyplot as plt from mpl_finance import candlestick_ochl from matplotlib.pylab import date2num import pandas as pd import numpy as np # 獲取貴州茅臺從2018年元旦至2023年3月20日的行情資料 df = ts.get_k_data('600519', start='2018-01-01', end='2023-03-20') # 計算MACD指標 def MACD(df, fastperiod=12, slowperiod=26, signalperiod=9): ewma12 = pd.Series.ewm(df['close'], span=fastperiod).mean() ewma26 = pd.Series.ewm(df['close'], span=slowperiod).mean() dif = ewma12 - ewma26 dea = pd.Series.ewm(dif, span=signalperiod).mean() macd = (dif - dea) * 2 return dif, dea, macd dif, dea, macd = MACD(df) # 畫圖展示 df['time'] = pd.to_datetime(df['date']) df['time'] = df['time'].apply(date2num) df = df[['time', 'open', 'close', 'high', 'low']] fig, ax = plt.subplots(figsize=(20, 10)) candlestick_ochl(ax, df.values, width=0.6, colorup='red', colordown='green', alpha=0.8) plt.plot(dif, label='DIF', color='blue') plt.plot(dea, label='DEA', color='orange') plt.bar(macd.index, macd, label='MACD', color='purple') plt.legend() plt.title('Guizhou Maotai Stock Price with MACD') plt.xlabel('Date') plt.ylabel('Price') plt.show()
可執行
9.WEB
用python爬取成都的7天內的天氣，轉換成WEB程式：- 使用Python Flask編寫後端程式碼- 前端頁面靜態頁面， 展示天氣圖示
from flask import Flask, render_template_string import requests from bs4 import BeautifulSoup app = Flask(__name__) @app.route('/') def home(): # Scrape weather data from website url = 'https://www.weather.com/zh-CN/weather/5day/l/CHXX0006:1:CH' response = requests.get(url) print("Start to crawling") soup = BeautifulSoup(response.content, 'html.parser') days = soup.find_all('h3', class_='DailyContent--daypartName--3G5Y8') temps = soup.find_all('div', class_='DailyContent--temp--_8DL5') icons = soup.find_all('img', class_='DailyContent--icon--2s5M5') weather_data = [] for i in range(len(days)): day = days[i].text temp = temps[i].text icon = icons[i]['alt'] weather_data.append({'day': day, 'temp': temp, 'icon': icon}) print(weather_data) # Render template with weather data template = """ <!DOCTYPE html> <html> <head> <title>Weather App</title> </head> <body> <h1>5-Day Weather Forecast</h1> <table> <thead> <tr> <th>Day</th> <th>Temperature</th> <th>Icon</th> </tr> </thead> <tbody> {% for data in weather_data %} <tr> <td>{{ data.day }}</td> <td>{{ data.temp }}</td> <td>{{ data.icon }}</td> </tr> {% endfor %} </tbody> </table> </body> </html> """ return render_template_string(template, weather_data=weather_data) if __name__ == '__main__': app.run()
爬蟲有問題，程式有的包都沒匯入。
10.電機控制
用C語言寫一個控制直流電機的演算法。要求包括啟動電機、多檔加速電機、停止電機、基於PID演算法對電機速度進行控制
View Code不知道對不對
11.Verilog HDL
加法器 乘法器 矩陣乘法
// This is a Verilog code for a simple adder module adder(input a, input b, output sum); assign sum = a + b; endmodule // This is a Verilog code for a simple multiplier module multiplier(input a, input b, output mult); assign mult = a * b; endmodule // This is a Verilog code for a matrix multiplication module module matrix_multiplier( input [3:0][3:0] matrix_A, // 4x4 matrix A input [3:0][3:0] matrix_B, // 4x4 matrix B output [3:0][3:0] matrix_C // 4x4 matrix C = A * B ); genvar i, j, k; wire [7:0] temp; generate // Multiply each element of matrix A with corresponding element of matrix B // and accumulate the results to get each element of matrix C for (i = 0; i < 4; i = i + 1) begin : ROWS_C for (j = 0; j < 4; j = j + 1) begin : COLS_C assign temp = 8'h0; for (k = 0; k < 4; k = k + 1) begin : ELEMENTS_A_B assign temp = temp + matrix_A[i][k] * matrix_B[k][j]; end assign matrix_C[i][j] = temp; end end endgenerate endmodule
不知道對不對
12.執行緒池
用Java寫一個執行緒池，並給出測試樣例
import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ThreadPoolExample { public static void main(String[] args) { ExecutorService executor = Executors.newFixedThreadPool(5); for (int i = 0; i < 10; i++) { Runnable worker = new WorkerThread("" + i); executor.execute(worker); } executor.shutdown(); while (!executor.isTerminated()) { } System.out.println("Finished all threads"); } } class WorkerThread implements Runnable { private String message; public WorkerThread(String s) { this.message = s; } public void run() { System.out.println(Thread.currentThread().getName() + " (Start) message = " + message); processMessage(); System.out.println(Thread.currentThread().getName() + " (End)"); } private void processMessage() { try { Thread.sleep(2000); } catch (InterruptedException e) { e.printStackTrace(); } } }
不知道對不對
總結比較強大的全能程式碼寫手，但是需要設定合適的問題。
能夠完成初級問題解答，有時可能比搜尋快。