# 安装Homebrew
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# 将Homebrew添加到PATH环境变量
echo 'eval "$(/opt/homebrew/bin/brew shellenv)"' >> ~/.zshrc
source ~/.zshrc

# 安装Python和基础依赖
brew install python cmake protobuf rust

# 创建名为bert_env的虚拟环境
python -m venv ~/bert_env

# 激活虚拟环境
source ~/bert_env/bin/activate

# 升级pip和setuptools
pip install --upgrade pip setuptools wheel

pip install torch torchvision torchaudio --extra-index-url https://download.pytorch.org/whl/nightly/cpu

# 验证安装是否成功
python -c "import torch; print(torch.__version__); print(torch.backends.mps.is_available())"

pip install transformers sentencepiece numpy pandas tqdm scikit-learn matplotlib jupyterlab

# 可选：如果你想使用TensorFlow而不是PyTorch
pip install tensorflow-macos tensorflow-metal

from transformers import BertTokenizer, BertModel

# 下载并保存bert-base-uncased模型和分词器
model_name = "bert-base-uncased"
tokenizer = BertTokenizer.from_pretrained(model_name)
model = BertModel.from_pretrained(model_name)

# 保存到本地以便后续使用(可选)
save_path = "./bert_model"
tokenizer.save_pretrained(save_path)
model.save_pretrained(save_path)

import torch
from transformers import BertTokenizer, BertModel

# 检查是否可以使用MPS加速(M3 GPU)
device = torch.device("mps" if torch.backends.mps.is_available() else "cpu")
print(f"Using device: {device}")

# 加载模型和分词器
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertModel.from_pretrained('bert-base-uncased').to(device)

# 准备输入文本并分词化
text = "Hello, my name is John and I love natural language processing!"
inputs = tokenizer(text, return_tensors="pt").to(device)

# 获取模型输出(禁用梯度计算以节省内存)
with torch.no_grad():
    outputs = model(**inputs)

# [CLS]标记的输出可用于分类任务等用途(last_hidden_state的形状为[batch_size, sequence_length, hidden_size])
print(f"Last hidden state shape: {outputs.last_hidden_state.shape}")
print(f"Pooler output shape: {outputs.pooler_output.shape}")

Using device: mps
Last hidden state shape: torch.Size([1, 16, 768])
Pooler output shape: torch.Size([1, 768])

model = model.half()  # 转换为半精度浮点数(Float16)
inputs = inputs.to(torch.float16)

model = torch.jit.trace(model, [inputs["input_ids"], inputs["attention_mask"]])

brew install rustup-init && rustup-init -y --default-toolchain stable --profile minimal --component rustfmt clippy rust-src && source $HOME/.cargo/env && pip install tokenizers --no-binary :all:

pip install jupyterlab ipywidgets widgetsnbextension pandas scikit-learn matplotlib seaborn plotly pyarrow fastparquet notebook jupyter_contrib_nbextensions jupyter_nbextensions_configurator autopep8 flake8 yapf black isort rope jedi ipython_genutils traitlets jupyter_core nbformat nbconvert jinja2 entrypoints defusedxml mistune pandocfilters webencodings bleach markupsafe pygments ptyprocess pexpect terminado prometheus_client Send2Trash parso wurlitzer zipp importlib_metadata typing_extensions jsonschema attrs pyrsistent six rfc3986 urllib3 idna chardet certifi requests tornado pyzmq jupyter_client ipykernel nbclient nest_asyncio async_generator argon2_cffi notebook_shim terminado prometheus_client websocket-client sniffio anyio trio outcome sortedcontainers async-timeout aiohttp yarl multidict frozenlist charset_normalizer httpx rfc3339_validator isoduration uri_template jsonschema_spec_names referencing referencing._core referencing._core._core referencing._core._exceptions referencing._jsonschema referencing.exceptions requests_toolbelt packaging pyparsing pydantic_core pydantic typing_inspect annotated_types pydantic_extra_types email_validator python_dateutil python_multipart fastapi starlette uvicorn watchfiles click h11 httptools python-dotenv uvloop watchfiles websockets rich typer shellingham colorama distro sniffio anyio httpcore certifi h11 httpcore httpie httpx itsdangerous werkzeug flask flask_cors openapi_schema_pydantic openapi_spec_validator prance apispec marshmallow apispec-webframeworks connexion swagger-ui-bundle openapi-spec-validator jsonschema-specifications jsonpointer jsonref jsonpatch jsonmerge fastjsonschema openapi-schema-validator openapi-core openapi-spec-validator prance apispec connexion flask-restx flask-restful eve apistar hug falcon bottle pyramid morepath tornado sanic responder starlette fastapi blacksheep quart aiohttp vibora japronto responder muffin bocadillo sanic-testing quart-trio hypercorn uvicorn daphne gunicorn cherrypy waitress paste werkzeug meinheld bjoern eventlet gevent twisted diesel meinheld-gunicorn meinheld-supervisor gunicorn meinheld meinheld-gunicorn meinheld-supervisor gunicorn-eventlet gunicorn-gevent gunicorn-tornado gunicorn-twisted gunicorn-meinheld gunicorn-bjoern gunicorn-paste gunicorn-werkzeug uwsgi mod_wsgi passenger phusion-passenger circus honcho supervisor supervisord supervisor-stdout circus-web flower huey rq dramatiq celery redis kombu vine billiard amqp pika py-amqplib redis-py-cluster redis hiredis aioredis rediscluster aredis walrus redislite fakeredis mockredispy redislite fakeredis mockredispy redislite fakeredis mockredispy redislite fakeredis mockredispy redislite fakeredis mockredispy redislite fakeredis mockredispy redislite fakeredis mockredispy redislite fakeredis mockredispy redislite fakeredis mockredispy redislite fakeredis mockredispy redislite fakeredis mockredispy redislite fakeredis mockredispy redislite fakeredis mockredispy redislite fakeredis mockredispy redislite fakeredis mockredispy redislite fakeredis mockredispy redislite fakeredis mockredispy redislite fakeredis mockredispy redis-py-asyncio redis-py-cluster-asyncio aredis-asyncio walrus-asyncio aioredlock aiorwlock aiohttp-client-cache aiodataloader aiocache aioredis-py aioredis-cluster-py asyncio-redis asyncio-redis-cluster asyncio-redlock asyncio-rwlock asyncio-cache asyncio-dataloader asyncio-memcache asyncio-mongo asyncio-mysql asyncio-postgresql asyncio-sqlalchemy asyncio-sqlite asyncio-tinydb asyncio-zookeeper django-redis django-redis-cache django-redissessions django-redistemplate django-rq django-celery-results django-celery-beat flower django-q huey django-huey dramatiq-django rq-django celery-django redis-django channels-rediskombu channels-rediskombu-py channels-rediskombu-py3 channels-rediskombu-py36 channels-rediskombu-py37 channels-rediskombu-py38 channels-rediskombu-py39 channels-rediskombu-py310 channels_redis channels_redis.core channels_redis.pubsub channels_redis.client aioredisc kombu redis celery[redis] flower huey rq dramatiq[redis] celery[redis] flower huey rq dramatiq[redis] celery[redis] flower huey rq dramatiq[redis] celery[redis] flower huey rq dramatiq[redis] celery[redis] flower huey rq dramatiq[redis] celery[redis] flower huey rq dramatiq[redis] celery[redis] flower hueeey rqq dramatiqq[[reiddiss]] celerry[[reiddiss]] flowwer huueey rrqq draamattiiqq[[reiddiss]] celerry[[reiddiss]] flowwer huueey rrqq draamattiiqq[[reiddiss]] celerry[[reiddiss]] flowwer huueey rrqq draamattiiqq[[reiddiss]] celerry[[reiddiss]] flowwer huueey rrqq draamattiiqq[[reiddiss]] celerry[[reiddiss]] flowwer huueey rrqq draamattiiqq[[reiddiss]] celerry[[reiddiss]] flowwer huueey rrqq draamattiiqq[[reiddiss]]
jupyter notebook --port=8888 --no-browser --ip=0.0.0.0 --allow-root --NotebookApp.token='' --NotebookApp.password=''

%%timeit -n1 -r1 

from transformers import BertTokenizer, BertModel 
import torch 

device = "mps" if torch.backends.mps.is_available() else "cpu" 
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased') 
model = BertModel.from_pretrained('bert-base-uncased').to(device) 

texts = ["This is a test sentence.", "Another example text for BERT."]
inputs = tokenizer(texts, return_tensors="pt", padding=True, truncation=True).to(device) 

with torch.no_grad(): 
    outputs = model(**inputs) 

print(f"Embedding shape: {outputs.last_hidden_state.shape}")

from transformers import BertForSequenceClassification, AdamW, get_linear_schedule_with_warmup
from sklearn.model_selection import train_test_split 
import pandas as pd 
import numpy as np 
import torch.nn.functional as F 
import torch 

# Step1:准备示例数据 (情感分析数据集示例)
data = {
    'text': [
        'I love this movie!', 'This product is terrible.', 
        'The service was excellent.', 'Would not recommend this hotel.',
        'Great experience overall.', 'Worst purchase ever.'
    ],
    'label': [1,0,1,0,1,0]
}
df = pd.DataFrame(data)

# Step2:分割训练集和测试集 
train_texts, val_texts, train_labels, val_labels = train_test_split(
    df['text'].tolist(), df['label'].tolist(), test_size=0.2)

# Step3:加载分词器和编码数据 
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')

train_encodings = tokenizer(train_texts, truncation=True, padding=True)
val_encodings = tokenizer(val_texts, truncation=True, padding=True)

class TextDataset(torch.utils.data.Dataset):
    def __init__(self, encodings, labels):
        self.encodings = encodings 
        self.labels = labels 

    def __getitem__(self, idx):
        item = {key: torch.tensor(val[idx]) for key, val in self.encodings.items()}
        item['labels'] = torch.tensor(self.labels[idx])
        return item

    def __len__(self):
        return len(self.labels)

train_dataset = TextDataset(train_encodings, train_labels)
val_dataset = TextDataset(val_encodings, val_labels)

# Step4:加载预训练模型并微调 (二分类任务)
model = BertForSequenceClassification.from_pretrained('bert-base-uncased', num_labels=2).to(device)

optimizer = AdamW(model.parameters(), lr=5e-5)
train_loader = torch.utils.data.DataLoader(train_dataset,batch_size=16, shuffle=True)
val_loader=torch.utils.data.DataLoader(val_dataset,batch_size=16)

for epoch in range(3): #通常需要更长时间训练实际任务中!
    model.train()
    total_loss=0

    for batch in train_loader:
        optimizer.zero_grad()

        input_ids=batch['input_ids'].to(device)
        attention_mask=batch['attention_mask'].to(device)
        labels=batch['labels'].to(device)  

        outputs=model(input_ids,
                     attention_mask=attention_mask,
                     labels=labels)  

        loss=outputs.loss  
        total_loss+=loss.item()

        loss.backward()  
        optimizer.step()  

    avg_train_loss=total_loss/len(train_loader)  

    #验证步骤  
    model.eval()
    total_eval_loss,eval_steps=0.,0

    with torch.no_grad():  
       for batch in val_loader:
           input_ids=batch['input_ids'].to(device)  
           attention_mask=batch['attention_mask'].to(device)  
           labels=batch['labels'].to(device)  

           outputs=model(input_ids,
                        attention_mask=attention_mask,
                        labels=labels)  

           loss=outputs.loss  
           total_eval_loss+=loss.item()  
           eval_steps+=1  

       avg_val_loss=(total_eval_loss/eval_steps)  

       print(f'Epoch:{epoch},Train Loss:{avg_train_loss:.4f},Val Loss:{avg_val_loss:.4f}')  

print("Training complete!")

pip uninstall torch -y   #移除PyTorch以节省空间 (可选步骤)
pip install tensorflow-macos tensorflow-metal transformers[tf-cpu]