HuggingFaceGuidedTourForMac
1.0.0
Um tour guiado sobre como instalar pytorch otimizado e, opcionalmente, o novo MLX da Apple e/ou tensorflow ou JAX do Google em Apple Silicon Macs e como usar modelos de linguagem grande HuggingFace para seus próprios experimentos. Mac recentes mostram bom desempenho para tarefas de aprendizado de máquina.
Realizaremos as seguintes etapas:
homebrewpytorch com suporte a MPS (metal performance shaders) usando GPUs Apple Siliconmlx da AppleJAX com drivers metálicos da Apple (experimental é neste momento (2024-07) e nem sempre atualizado).tensorflow com as otimizações de driver de metal conectável de metal da Applejupyter lab para executar notebookshuggingface e execute alguns modelos de linguagem pré-treinados usando transformers e apenas algumas linhas de código no Jupyter Lab.Em seguida, fornecemos instruções adicionais para:
(pule para 1. Preparativos se você souber qual estrutura irá usar)
Tensorflow, JAX, Pytorch e MLX são estruturas de aprendizado profundo que fornecem as bibliotecas necessárias para executar operações otimizadas de tensor usadas em treinamento e inferência. Em alto nível, a funcionalidade de todos os quatro é equivalente. Huggingface se baseia em qualquer uma dessas estruturas e fornece uma grande biblioteca de modelos pré-treinados para muitos casos de uso diferentes, prontos para uso ou para personalizar, além de uma série de bibliotecas convenientes e código de amostra para facilitar os primeiros passos.
jax-metal nem sempre está atualizado com as versões mais recentes do JAX .HuggingFace publica uma visão geral do suporte de modelo para cada estrutura. Atualmente, Pytorch é o padrão de fato, caso você queira fazer uso de modelos existentes.
Para a resposta (provavelmente muito simplificada) à pergunta "Qual é o mais rápido?" dê uma olhada no notebook Jupyter 02-Benchmarks e, depois de concluir a instalação, você poderá testar seu próprio ambiente. O notebook permite comparar a velocidade das multiplicações de matrizes para diferentes frameworks. No entanto, a diferença entre estruturas ao realizar treinamento de modelo “padrão” ou tarefas de inferência provavelmente será menos pronunciada.
Caso ainda não tenha feito isso, acesse https://brew.sh/ e siga as instruções para instalar o homebrew. Feito isso, abra um terminal e digite brew --version para verificar se está instalado corretamente.
Agora use brew para instalar versões mais recentes de python e git . A recomendação é usar o Python 3.12 padrão do Homebrew, se você não planeja usar o Tensorflow com otimização Metal (ainda requer 3.11 (em 2024-04)).
brew install [email protected] gitbrew install [email protected] gitvocê pode instalar ambas as versões do Python e então criar um ambiente virtual usando a versão específica do Python necessária para cada caso.
Se você planeja usar também Linux, esteja ciente de que o suporte à versão Python às vezes difere entre as versões de estruturas para Mac e Linux.
A Apple não investe muita energia para manter o python do MacOS atualizado. Se você quiser usar um python padrão atualizado, faz sentido tornar o python do homebrew o python do sistema padrão. Então, se você quiser usar o sistema Python 3.11 ou 3.12 do homebrew globalmente, a maneira mais fácil de fazer isso (após
brew install [email protected]ou3.11):
Edite ~/.zshrc e insira:
# This is OPTIONAL and only required if you want to make homebrew's Python 3.12 as the global version:
export PATH= " /opt/homebrew/opt/[email protected]/bin: $PATH "
export PATH=/opt/homebrew/opt/[email protected]/libexec/bin: $PATH Altere todas as referências de 3.12 para 3.11 quando quiser tornar o python padrão do sistema Python 3.11 do homebrew.
(Reinicie seu terminal para ativar as alterações de caminho ou digite source ~/.zshrc em sua sessão de terminal atual.)
Independentemente do sistema python em uso, ao criar um ambiente virtual, você sempre pode selecionar a versão específica do python que deseja usar no
venvcriando ovenvexatamente com esse python. Por exemplo,/usr/bin/python3 -m venv my_venv_namecria um ambiente virtual usando o macOS python da Apple (que no momento da redação deste artigo, 2024-07, ainda estava travado em 3.9.6). Veja abaixo, Ambientes Virtuais , para mais detalhes.
Agora clone este projeto como um projeto de teste:
git clone https://github.com/domschl/HuggingFaceGuidedTourForMac Isso clona o projeto de teste em um diretório HuggingFaceGuidedTourForMac
Agora crie um ambiente Python 3.12 para este projeto e ative-o:
(Novamente: substitua por 3.11 , se precisar)
python3.12 -m venv HuggingFaceGuidedTourForMac A criação de um venv adiciona os arquivos necessários (binários python, bibliotecas, configurações) para o ambiente virtual python à pasta do projeto que acabamos de clonar, usando novamente o mesmo diretório HuggingFaceGuidedTourForMac . Entre no diretório e ative o ambiente virtual:
cd HuggingFaceGuidedTourForMac
source bin/activate Agora o diretório HuggingFaceGuidedTourForMac contém o conteúdo do repositório github (por exemplo, 00-SystemCheck.ipynb ) e os arquivos para o ambiente virtual (por exemplo, bin , lib , etc , include , share , pyvenv.cfg ):
Alternativas: Se você tiver muitas versões diferentes do python instaladas, poderá criar um ambiente que use uma versão específica especificando o caminho do python usado para criar o venv , por exemplo:
/opt/homebrew/opt/[email protected]/bin/python3.12 -m venv my_new_312_env usa python do homebrew explicitamente para criar um novo venv , enquanto
/usr/bin/python3 -m venv my_old_system_venvusaria a versão macOS python da Apple para o novo ambiente.
Desative este ambiente virtual, basta usar:
deactivate Para reativá-lo, entre no diretório que contém o venv , aqui: HuggingFaceGuidedTourForMac e use:
source bin/activatevenvUma propriedade pouco intuitiva do
venvé o fato: enquanto você entra em um ambiente ativando-o no subdiretório do seu projeto (comsource bin/activate), ovenvpermanece ativo quando você sai da pasta do projeto e começa a trabalhar em algo completamente diferente até você desativa explicitamente ovenvcomdeactivate.Existem várias ferramentas que modificam o prompt do sistema de terminal para exibir o
venvatualmente ativo, o que é muito útil. Confira Starship (recomendado) ou, se você gosta de enfeites,Oh My Zsh.
Exemplo com powerlevel10k instalado. O lado esquerdo do prompt do sistema mostra o diretório atual, o lado direito mostraria o nome do venv . Atualmente, nenhum venv está ativo.
Depois de ativar um venv em HuggingFaceGuidedTourForMac :
Mesmo que o diretório de trabalho seja alterado (aqui para home ), como o venv ainda está ativo, seu nome é exibido no lado direito por powerlevel10k . Muito útil.
Consulte https://docs.python.org/3/tutorial/venv.html para obter mais informações sobre ambientes virtuais Python.
pytorch Certifique-se de que seu ambiente virtual esteja ativo com pip -V (V maiúsculo), isso deve mostrar um caminho para pip dentro do seu projeto:
<your-path>/HuggingFaceGuidedTourForMac/lib/python3.12/site-packages/pip (python 3.12)
Seguindo https://pytorch.org , instalaremos o Pytorch com pip . Você precisa de pelo menos a versão 2.x (padrão desde 2023) para obter suporte MPS (Metal Performance Shaders) no pytorch, que oferece vantagem significativa de desempenho no Apple Silicon.
Para instalar o pytorch no venv :
pip install -U torch numpy torchvision torchaudio Para testar se o pytorch está instalado corretamente e se os shaders de desempenho de metal MPS estão disponíveis, abra um terminal, digite python e dentro do shell python, digite:
import torch
# check if MPS is available:
torch . backends . mps . is_available () Isso deve retornar True .
MLX pip install -U mlx Novamente, inicie python e digite:
import mlx . core as mx
print ( mx . __version__ ) Isso deve imprimir uma versão, como 0.16.1 (2024-07)
JAX JAX é uma excelente escolha se o seu foco for a otimização de baixo nível de algoritmos e a pesquisa além dos limites dos algoritmos de aprendizagem profunda estabelecidos. Modelado após numpy , ele suporta diferenciação automática de 'tudo' (para problemas de otimização) e suporta vetorização e paralelização de algoritmos python além do mero aprendizado profundo. Para obter a funcionalidade esperada de outras estruturas de aprendizagem profunda (camadas, funções de loop de treinamento e 'alto nível' semelhantes), considere instalar uma biblioteca de rede neural adicional, como: flax .
Infelizmente, os drivers JAX metal começaram a ficar atrás das versões JAX e, portanto, você precisa verificar a tabela de compatibilidade para as versões suportadas do JAX que correspondem aos drivers jax-metal disponíveis.
Para instalar uma versão específica do JAX e o jax-metal mais recente com pip no ambiente ativo:
# The version 0.4.26 is taken from the compatibility table mentioned above. Update as required.
pip install -U jax==0.4.26 jaxlib==0.4.26 jax-metal Inicie python (3.12 é compatível) e digite:
import jax
print ( jax . devices ()[ 0 ])Isso deve ser exibido (somente na primeira execução):
Platform 'METAL' is experimental and not all JAX functionality may be correctly supported!
WARNING: All log messages before absl::InitializeLog() is called are written to STDERR
W0000 00:00:1721975334.430133 43061 mps_client.cc:510] WARNING: JAX Apple GPU support is experimental and not all JAX functionality is correctly supported!
Metal device set to: Apple M2 Max
systemMemory: 32.00 GB
maxCacheSize: 10.67 GB
I0000 00:00:1721975334.446739 43061 service.cc:145] XLA service 0x60000031d100 initialized for platform METAL (this does not guarantee that XLA will be used). Devices:
I0000 00:00:1721975334.446771 43061 service.cc:153] StreamExecutor device (0): Metal, <undefined>
I0000 00:00:1721975334.448269 43061 mps_client.cc:406] Using Simple allocator.
I0000 00:00:1721975334.448308 43061 mps_client.cc:384] XLA backend will use up to 22906109952 bytes on device 0 for SimpleAllocator.
[METAL(id=0)]
Aqui METAL:0 é o dispositivo que o JAX usará para cálculos, e Apple Silicon é compatível.
Se, em vez disso, você vir erros como:
RuntimeError: Unable to initialize backend 'METAL': INVALID_ARGUMENT: Mismatched PJRT plugin PJRT API version (0.47) and framework PJRT API version 0.54). (you may need to uninstall the failing plugin package, or set JAX_PLATFORMS=cpu to skip this backend.)
Sua versão do jax e jaxlib é incompatível com jax-metal . Verifique a tabela de compatibilidade do jax-metal e instale as versões necessárias conforme indicado na tabela.
tensorflowO Tensorflow está perdendo suporte rapidamente e nem mesmo o Google publica novos modelos para o Tensorflow. Um plano de migração é recomendado, se você planeja usá-lo.
Embora o Tensorflow suporte Python 3.12 desde 2.16, o acelerador
tensorflow-metaldo macOS não foi atualizado desde 2023-09 (status de 2024-07) e requer Python 3.11:
Certifique-se de que seu ambiente virtual esteja ativo com pip -V (V maiúsculo), isso deve mostrar um caminho para pip dentro do seu projeto:
<your-path>/HuggingFaceGuidedTourForMac/lib/python3.11/site-packages/pip (python 3.11)
Seguindo https://developer.apple.com/metal/tensorflow-plugin/, instalaremos tensorflow com pip dentro de nosso venv :
pip install -U tensorflow tensorflow-metal Para testar se o tensorflow está instalado corretamente, abra um terminal, digite python e dentro do shell python, digite:
import tensorflow as tf
tf . config . list_physical_devices ( 'GPU' )Você deverá ver algo como:
[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]
Neste ponto, seu Apple Silicon Mac deve estar pronto para executar pytorch e opcionalmente MLX e/ou JAX ou tensorflow com suporte para aceleração de hardware, usando o framework Apple Metal.
Para testar isso, você pode usar jupyter lab para executar alguns notebooks. Para instalar jupyter lab , primeiro certifique-se de que o ambiente virtual que você deseja usar esteja ativo ( pip -V ) e digite:
pip install -U jupyterlab ipywidgetsSe você tiver outras versões do Jupyter instaladas, o caminho para a versão do Jupyter recém-instalada dentro do
venvgeralmente não é atualizado corretamente, reative o ambiente para garantir que a versão local correta do Jupyter seja usada:
deactivate
source bin/activatePara iniciar o laboratório Jupyter, digite:
jupyter lab Isso deve abrir uma janela do navegador com jupyter lab em execução. Você pode então criar um novo notebook python e executar algum código para testar se tensorflow e pytorch estão funcionando corretamente:
import torch
print ( "Pytorch version:" , torch . __version__ )Se isso for concluído com êxito, seu Mac estará pronto para experimentos de aprendizado profundo.
HuggingFace é um ótimo recurso para experimentos de PNL e aprendizado profundo. Ele fornece um grande número de modelos de linguagem pré-treinados e uma API simples para usá-los. Isso nos permitirá iniciar rapidamente os experimentos de Deep Learning.
transformers A partir das instruções de instalação do huggingface, usamos pip para instalar transformers :
pip install -U transformers accelerate " huggingface_hub[cli] "Ao experimentar o HuggingFace, você baixará modelos grandes que serão armazenados em seu diretório inicial em:
~/.cache/huggingface/hub. Você pode remover esses modelos a qualquer momento, excluindo este diretório ou partes de seu conteúdo.
accelerate é opcional, mas usado para executar alguns modelos grandes. O efeito colateral da instalação accelerate pode ser o downgrade de alguns outros módulos como numpy ."huggingface_hub[cli]" instala as ferramentas de linha de comando huggingface que às vezes são necessárias para baixar modelos (parcialmente licenciados de forma proprietária) como o Llama 3. Dentro do diretório HuggingFaceGuidedTourForMac e venv ativo, inicie jupyter lab e carregue o notebook 00-SystemCheck.ipynb . O notebook irá primeiro verificar todos os frameworks de aprendizagem profunda e fornecer informações, se estiverem instalados corretamente. Posteriormente, o Pytorch é usado para um experimento simples.
Use <Shift>-Enter para executar as células do notebook.
Se você iniciou o Jupyter Lab antes de instalar o Huggingface, será necessário reiniciar o kernel python no Jupyter ou simplesmente reiniciar o Jupyter Lab, caso contrário, ele não encontrará a biblioteca Transformers.
Após os vários testes, você finalmente verá algo assim:
Se você recebeu uma classificação de rótulo POSITIVE com uma pontuação de 0.99 , então você está pronto para começar a experimentar o HuggingFace!
Você verá que as bibliotecas
HuggingFaceestão baixando todos os tipos de grandes blobs binários contendo os dados do modelo treinado. Esses dados são armazenados em seu diretório inicial em:~/.cache/huggingface/hub. Você pode remover esses modelos a qualquer momento, excluindo este diretório ou partes de seu conteúdo.
Você pode abrir o notebook 01-ChatBot.ipynb para experimentar um chatbot muito simples no seu Mac.
O código python usado é:
import torch
from transformers import AutoModelForCausalLM , AutoTokenizer
from transformers . utils import logging
# Disable warnings about padding_side that cannot be rectified with current software:
logging . set_verbosity_error ()
model_names = [ "microsoft/DialoGPT-small" , "microsoft/DialoGPT-medium" , "microsoft/DialoGPT-large" ]
use_model_index = 1 # Change 0: small model, 1: medium, 2: large model (requires most resources!)
model_name = model_names [ use_model_index ]
tokenizer = AutoTokenizer . from_pretrained ( model_name ) # , padding_side='left')
model = AutoModelForCausalLM . from_pretrained ( model_name )
# The chat function: received a user input and chat-history and returns the model's reply and chat-history:
def reply ( input_text , history = None ):
# encode the new user input, add the eos_token and return a tensor in Pytorch
new_user_input_ids = tokenizer . encode ( input_text + tokenizer . eos_token , return_tensors = 'pt' )
# append the new user input tokens to the chat history
bot_input_ids = torch . cat ([ history , new_user_input_ids ], dim = - 1 ) if history is not None else new_user_input_ids
# generated a response while limiting the total chat history to 1000 tokens,
chat_history_ids = model . generate ( bot_input_ids , max_length = 1000 , pad_token_id = tokenizer . eos_token_id )
# pretty print last ouput tokens from bot
return tokenizer . decode ( chat_history_ids [:, bot_input_ids . shape [ - 1 ]:][ 0 ], skip_special_tokens = True ), chat_history_ids
history = None
while True :
input_text = input ( "> " )
if input_text in [ "" , "bye" , "quit" , "exit" ]:
break
reply_text , history_new = reply ( input_text , history )
history = history_new
if history . shape [ 1 ] > 80 :
old_shape = history . shape
history = history [:, - 80 :]
print ( f"History cut from { old_shape } to { history . shape } " )
# history_text = tokenizer.decode(history[0])
# print(f"Current history: {history_text}")
print ( f"D_GPT: { reply_text } " )Isso mostra um chatbot (bastante limitado e repetitivo) usando modelos DialoGPT da Microsoft.
Coisas para tentar:
use_model_index entre 0..2 , você pode selecionar um modelo de linguagem pequeno, médio ou grande.history_text acima.~/.cache/huggingface/hub . O material ausente é baixado automaticamente novamente quando necessário. llama.cpp que implementa o código de inferência necessário para executar LLMs em código C++ altamente otimizado, suportando a aceleração Metal do Mac.Este parágrafo é para desinstalar o conda que foi usado em versões anteriores deste guia:
brew uninstall miniconda
Modificações adicionais são (todas elas ficam inativas, uma vez que o miniconda é removido):
~/.condarc (lista de canais) e ~/.conda .~/.zshrc (ou .bashrc ) para a configuração do caminho e do ambiente.~/.cache/huggingface/hub . Simplesmente remova o diretório. conda para pip e venv para as versões mais recentes do tensorflow 2.13, Pytorch 2, macOS Sonoma, a instalação agora é muito mais simples.pytorch v2.0 foi lançado, o canal pytorch-nightly agora pode ser substituído pelo pytorch nas instruções de instalação. O canal pytorch-nightly não é mais necessário para suporte MPS.
