Best match

Most recent

Minnesota

Investors, employees and other stakeholders over the last decade increasingly pushed companies to improve goals in these areas and be transparent about their progress. Stoking even more disclosure are plans to require standardize reporting on some measures by the European Union and likely the U.

https://www.bing.com/th?id=OVFT.49oNtuU_8H3mYGE0gip50i&pid=News

Minnesota companies' progress on environmental goals obscured by lack of reporting standards

https://www.bing.com/th?id=ODF.vTokv88vvYScHJx7GCQpnA&pid=news

Star Tribune

RBC Capital analyst Ashish Sabadra reiterated a Buy rating on Ecolab (ECL – Research Report) today and set a price target of $213.00. The

Ecolab (ECL) Receives a Buy from RBC Capital

https://www.bing.com/th?id=ODF.LrIq_5vxtu4ONs5zIW54FA&pid=news

Business Insider

Miso Robotics makes products that do the most repetitive tasks in restaurant kitchens, such as making French fries and filling drinks.

With fast-food labor crunch, Ecolab invests in firm that makes restaurant robots

Challenges

During the forecast period 2023-2033, the cooling water treatment chemicals market is expected to grow at a value of 6% CAGR, according to Future Market Insights. By the year 2033, the global market for cooling water treatment chemicals is expected to rise up to a market valuation of US$ 12,

https://www.bing.com/th?id=OVFT.xaJm4jYzT1j0b8tHDEWKCi&pid=News

Analyzing the Growth Trends of the Cooling Water Treatment Chemicals Market: Opportunities and Challenges

Future Market Insights

Geography of Canada

CBC News

(Patrick Doyle/The Canadian Press) Toxic "forever chemicals" are being found in the blood of Canadians — and even higher levels are being found in northern Indigenous communities — says a new ...

'Forever chemicals' found in Canadians' blood samples: report

CBC.ca

Toxic "forever chemicals" are being found in the blood of Canadians — and even higher levels are being found in northern Indigenous communities — says a new report from the government of Canada. Health Canada and Environment Canada have released a ...

Yahoo News Canada

Baltimore

Authorities are responding to a chemical leak Friday at an industrial facility in south Baltimore.Baltimore City fire officials told 11 News that units were called for a chemical spill in the 5500 ...

Crews called to chemical spill at industrial facility in south Baltimore

WBAL-TV

Washington

The Washington state Legislature has passed some of the country’s strongest legislation to protect residents from hazardous chemicals in cosmetic products. Starting in 2025, the Toxics-Free ...

Washington passes law to cut ‘forever chemicals’ in makeup

Crosscut

Get the most recent info and news about Ecolab on HackerNoon, where 10k+ technologists publish stories for 4M+ monthly readers.

Ecolab Inc. provides water, hygiene, and infection prevention solutions and services in the United States and internationally. The company operates through Global Industrial, Global Institutional & Specialty, and Global Healthcare & Life Sciences segments. The Global Industrial segment offers water treatment and process applications, and cleaning and sanitizing solutions to manufacturing, food and beverage processing, transportation, chemical, metals and mining, power generation, pulp and paper, commercial laundry, petroleum, refining, and petrochemical industries. The Global Institutional & Specialty segment provides specialized cleaning and sanitizing products to the foodservice, hospitality, lodging, government and education, and retail industries. Its Global Healthcare & Life Sciences segment offers specialized cleaning and sanitizing products to the healthcare, personal care, and pharmaceutical industries, such as infection prevention and surgical solutions, and end-to-end cleaning and contamination control solutions under the Ecolab, Microtek, and Anios brand names. The company's Other segment offers pest elimination services to detect, eliminate, and prevent pests, such as rodents and insects in restaurants, food and beverage processors, educational and healthcare facilities, hotels, quick service restaurant and grocery operations, and other institutional and commercial customers. This segment also provides colloidal silica for binding and polishing applications in semiconductor, catalyst, and aerospace component manufacturing, as well as chemical industries; and products and services that manage wash process through custom designed programs, premium products, dispensing equipment, water and energy management, and reduction, as well as real time data management. It sells its products through field sales and corporate account personnel, distributors, and dealers. The company was founded in 1923 and is headquartered in Saint Paul, Minnesota.

Ecolab

I found myself formless, waking
up near the Asset Tree with this
predicting platform and really
wanted to do something broad
and correctively positive with it. It all clinged on quality, a síngle
leak in asset performance lured a
loop of leverage. When team-tool alerts demonstrated dripping operational upsets, the portal pause changed to cloud-based triggers. A chart-change of digital trends subtly raised, one stacked with smart alarms; so sustained as sensors' analytics. A chart like no shapeless other, that floated on three hundred pretreatment areas, then flowed through sixty mechanical grades mitigating the most minimal manual e-coats end-to-end in circuits. The current model of efficiency
effectively hinges on preventative
plans, panned still secured lines
as networks— one phosphate problem
embedded in e-vehicle bodies via overuse. One boost moment words would distill
through optimized solutions written
ripe in the area's best practices practicing real-time identification. So enormous those checklists were
at e-points, first in data's field-train
refining rigour, next to layered levels
of fuel waters' intelligence data; laid
plain and visible enterprise-wide. The last reacts for CIP; when driven through tracked trouble spots by laboratory data. Actionable parameters might very well verify that pace of completion; in certain certainty, combining controller data with customer KPIs. Integrity's transmission trend thinks outside of the automated box, then consolidates prescribed limits in the non-linear long term. The monitoring methodology stands
maintained in-scope granular efficacy
only when necessary.
Put into smart inventories it overcomes inadequacy; put into post-treatment anomalies it sets remote IIoT benchmarks for the needs of several incorporated industries ranging in sustainable impact. Had it not been for the smarter asset's
performance having highly correlated
foresight to sink the project's
cutting-edge, this dynamic insight
wouldn't have prioritized advanced
algorithms that enable detected
peace of mind.

ECOLAB3D: A Poem

One in five Americans their health with the help of fitness trackers or apps. During the first two quarters of 2020, there were over 1.2 billion of health and fitness apps. These facts indicate that people are interested in platforms that will allow them to track vital signs, control nutrition, and remotely communicate with doctors. Before starting a healthcare software project, a medical facility should decide what type of medical platform its target audience needs. Let’s take a look at the most popular apps and options for their use. controls downloads According to a by Statista, health apps are most frequently used in China (65%), India (63%), and Indonesia (57%). The Japanese (12%) and Europeans (22-40%) turn to mHealth less often. study People often use applications for a balanced diet. Platforms for monitoring heart rate, tracking vital signs, and meditation are also popular. The healthcare software market is not limited to this. There are at least 10 types of healthcare software that the medical industry can use. Health monitoring apps Healthcare providers are investing in remote monitoring apps. Insider Intelligence predicts that the global RPM systems market will be worth over $1.7 billion by 2027. Investing in such software is not only popular but also economically justified. Applications and devices for remote patient monitoring collect, process, and transmit information about users’ state of health. Here are some examples of such platforms: Hand hygiene monitoring software Such applications have become especially relevant during the pandemic. Although hand hygiene is a common practice for healthcare professionals, there have been introduced systems that control proper and timely disinfection. For example, Ecolab records every time medical workers wash their hands. It notifies users when the next disinfection is required. Thus, the system protects patients from possible infection. Ecolab includes three components: Patient directory — A user sees how often a nurse or a doctor washes hands. Disinfection statistics — The application records each hand washing and sends reminders to the medical staff. Reporting function — The chief physician collects information about employees to ensure they follow the WHO requirements and do not put patients at risk. Application to Fight Depression According to the WHO, about 280 million people in the world from depression. The actual figure might be higher if the unreported cases are counted. Many people experience negative emotions and do not realize that they are seriously ill. suffer Therefore, Stanford scientists are people suffering from depression. They want to create an application to monitor the state of patients before and after the treatment. They plan to build a device that continuously measures physiological parameters (cortisol levels in sweat, changes in heart rate, and so on) to assess a patient’s state of mind. IoT sensors also make it possible to predict, prevent and treat mental illnesses. trying to help Blood glucose monitoring platform It is a glucometer connected to a smartphone and an application for collecting data. The application reminds patients when they need to take a test, assesses blood sugar levels, and gives recommendations on nutrition and physical activity. Such measures allow a patient to control diabetes and live comfortably, despite the restrictions. The application can be used by a doctor who monitors the sick person or relatives taking care of them. Asthma monitoring system Such a system includes the following components: IoT devices with sensors collect information about respiratory rate, pulse, cough, and rales. A mobile application that collects and visualizes data, transfers it to a specialist, and reminds the patient about a visit to the doctor. A web application for storing medical history and statistics. Thanks to this device, the system predicts an approaching asthma attack. The patient manages to take medicine on time, and the doctor can evaluate the effectiveness of the prescribed drugs. Surgery Software Surgery actively uses software and robots to plan and carry out operations. In 2018, 5,000 robots helped doctors to more than a million procedures in orthopedics, surgery, neurology, otolaryngology, and other areas. perform Specially designed equipment and software help surgeons manage instruments and perform more complex operations on limited areas of the body without the risk to patients. Doctor Appointment Apps When a patient makes an appointment with a doctor and doesn’t show up for the consultation, the medical institution loses money. Forbes that due to such incidents American healthcare loses about $150 billion annually. states Doctor appointment apps help to partially solve this problem. The system helps to plan visits and reminds patients about appointments by email or via push notifications. The registration form is not confirmed until the patient fills in the required fields (full name, contact details, complaints). The information helps administrators to determine how long the visit will last. Doctors don’t need to fill out the documentation from scratch, they use the patient data recorded in the system, adding the necessary details. CRM for Healthcare 30% of patients clinics due to poor service. It is important for people that medical workers understand their needs and provide personalized care. are willing to change One could manage this issue with the help of customer relationship management software. Such an app improves the clinic’s communication with patients and the work of the organization. It helps to store medical histories and visit statistics, inform about new medical services, and analyze the work of the staff. If a clinic lacks such a tool, it is worth investing in healthcare software development and ordering such an application. Hospital Management Software While CRP optimizes communication with customers, hospital management software is responsible for the internal processes of a clinic. The system gathers information about the employees in an integrated interface to automate administrative operations not related to medical procedures. With the help of such a program, the organization performs the following tasks: It plans the medical equipment maintenance; Makes an inventory; Keeps track of deliveries; Manages hospital beds; Registers patients; Pays utility bills and performs other operations. Such software served well when hospitals were overcrowded with patients and people lacked ventilators and oxygen masks. The program helped to track the equipment and uninterruptedly transfer it to hospital wards for critical patients. Healthcare Analytics Platform Between 2013 and 2020, the global healthcare data volume 15 times to 2,134 exabytes. Healthcare is a leader in Big Data generation. Medical software, laboratories, human resources, and CRM produce loads of information. It must be skillfully analyzed to be used for the benefit of a medical institution, employees, and patients. increased Medical analytics systems process incoming information and single out valuable data which is used to: Set accurate diagnoses; Predict the treatment results; To manage the inventory and equipment; To monitor the state of equipment and for other purposes. The healthcare analytics market is predicted to $40 billion by 2025. reach Billing System It a week or a month for an average organization to manually process an invoice. For the healthcare sector, such delays are undesirable. The billing system automates the issuance and payment of electronic invoices. It takes less time and money, and fewer medical workers to carry out this procedure. takes This system complies with the Health Insurance Portability and Accountability Act (HIPAA) and easily integrates with accounting software. Some applications offer online payments, self-service, prepayment, and consulting. If a clinic has a poor bill payment system, it is worth starting healthcare software development with a project of a new efficient billing system. Software for Training and Retraining Medical Personnel Physicians need to constantly learn and improve their skills, and keep track of the latest advances in medicine, technological inventions, and novelties. Therefore, applications providing new knowledge enter the market: Software for e-learning. These are applications that collect the latest news from the healthcare industry and interactive libraries with a new knowledge base. The most popular are Medscape Mobile, Human Anatomy Atlas, and Brainscape. Software for practice. Such platforms contain VR/AR elements that help doctors to hone their skills in practice. For example, they can train for complex surgeries or practice invasive procedures. The hospital team can remotely improve their skills. Electronic Medical Records (EMR) An EMR is a program that digitally stores information about a patient. It includes a medical history, prescribed medications, a list of vaccinations, information about chronic diseases, and so on. Patients entrust their health data to the clinic, and doctors remotely monitor their health status. A doctor makes accurate and clear medical records, so their colleagues, pharmacists, and other employees do not have to read illegible handwriting. The fewer misunderstandings an EMR causes, the fewer medical errors occur. Advanced EMRs with IoT sensors and medical applications so that doctors can remotely monitor patients. integrate Telemedicine Apps Telemedicine is a rapidly developing healthcare sector. It gained immense popularity when the pandemic provoked a leap in the remote treatment of patients. In the US, online appointments 41% in 2020. The telemedicine market will from $49.9 billion in 2019 to $459.8 billion in 2030. A remote care application is a great idea for a healthcare software development project. constituted grow Telemedicine applications connect patients and doctors via chats, instant messengers, and video calls. A patient can consult a physician using their home computer, tablet, or smartphone. They can get an electronic prescription or a referral for lab tests. Why Clinics Should Invest in Healthcare Software Development The demand for healthcare apps is growing as they increase the competitive edge of hospitals and clinics. They provide: Instant and twenty-four-hour access to patient information. Access to medical records from any device, from any corner of the world. Easier exchange of medical data between hospitals, laboratories, and insurance companies. Personalized patient care. Optimization of internal operations. Doctors see more patients because they do not need to manually perform certain tasks. Simplified appointment making and remote consultations. Better coordination of clinic workflows, because the necessary information is stored in one place, and tasks are automated. Thanks to healthcare software, organizations save time, money, avoid medical errors and satisfy customers with the quality of services. Every modern healthcare institution strives to achieve such a result. Conclusion The medical applications mentioned above solve different problems, have different architecture and functions. But they serve a common goal which is to improve and modernize the healthcare industry. Thus, it will carry out its mission even better. When planning healthcare software development, you should define the purpose of the project and select the appropriate application type. Focus on those operations that need to be improved first. If the development process is set up correctly, the result will be rewarding for your healthcare facility.

As Healthcare App Popularity Rises, Organizations Need to Focus on New Software

A medida que aumenta la popularidad de las aplicaciones para el cuidado de la salud, las organizaciones deben centrarse en un nuevo software

Alors que la popularité des applications de santé augmente, les organisations doivent se concentrer sur de nouveaux logiciels

जैसे-जैसे हेल्थकेयर ऐप की लोकप्रियता बढ़ती है, संगठनों को नए सॉफ्टवेयर पर ध्यान देने की जरूरत है

ヘルスケア アプリの人気が高まる中、組織は新しいソフトウェアに注力する必要があります

À medida que a popularidade dos aplicativos de assistência médica aumenta, as organizações precisam se concentrar em novos softwares

Khi mức độ phổ biến của ứng dụng chăm sóc sức khỏe tăng lên, các tổ chức cần tập trung vào phần mềm mới

随着医疗保健应用程序受欢迎程度的提高，组织需要专注于新软件

Go Fast, Small, and Productive With GolangSpell

Google Colab and VS Code are the most popular editor tools used by many Python developers and Researchers to develop different tech solutions or systems (especially in Machine Learning & Data Science). Many Python developers and Data scientists know how to use Google Colab, but do you know that you can set up a VS Code on Google Colab and use it as an editor the same way as in your local machine? In this article, you will learn How to install the colabcode python package. How to start the VS Code (code server). How to access the online VS Code. Open the terminal. Run a python file. Steps on How to Use Google Colab with VS Code 1.Open Colab Notebook The first step is to launch a new colab notebook in your Google Colab and you can rename the file as you want. For example, run_vscode.ipynb . 2.Install colabcode python package To use Google Colab with VS Code (code server), you need to install the colabcode python package. This is an awesome open-source python package developed by . Abhishek Thakur To install the package, run the following command in your notebook cell. !pip install colabcode 3.Import ColabCode The next step is to import ColabCode class from the package. colabcode ColabCode from import 4.Create an instance of ColabCode After importing the ColabCode, you need to create an instance of ColabCode and set the following arguments. - The port you want to run code-server on. For example port=10000 port - You can set a password to protect your code-server from unauthorized access. This is an optional argument. password - If you want to use your Google drive. This is a Boolean argument means you can set True or False. This is an optional argument. mount_drive ColabCode(port= ) 10000 5.Start the Code Server After running the ColabCode instance, it will start the server and show the link to access the code server. You need to click the link and it will open in a new tab. Now you can take advantage of a full-fledged code editor and run different experiments on the Colab VM. If you check on your Colab Notebook, you will observe the cell that runs the ColabCode instance is continuously running. Don't close your Colab notebook unless you want to close the code server that runs VS Code. Note: Tips to use VS Code on Google Colab After launching the code server, the following tips will help you start using VS Code on Google Colab. 1.Open Terminal To open the terminal on VS Code that runs on Google Colab, use the following shortcut command Ctrl + Shift + ` 2.Change Theme You can change the theme of the editor by clicking the setting icon (bottom-left corner) and then click "Color Theme". It will open a popup window with different theme options you can select. 3.Run Python File You can create a python file by clicking the "File" section on the sidebar and then select a "New File" tab. In the following example, you will see how to run a simple python file that trains a machine-learning algorithm to classify iris flowers into three species (setosa, versicolor, or virginica) and then make a prediction. Final Thoughts on How to use Google Colab with VS Code Congratulations 👏👏, you have made it to the end of this article! I hope you have learned something new. You can set up VS Code on Google Colab and take your coding to the next level. You can also use the colabcode python package on the Kaggle platform to run VS Code. You just need to follow the same steps mentioned above. If you learned something new or enjoyed reading this article, please share it so that others can see it. Until then, see you in the next post! You can also find me on Twitter . @Davis_McDavid And you can read more articles like this . here Want to keep up to date with all the latest in python? in the footer below! Subscribe to our newsletter

How To use Google Colab with VS Code

Cómo usar Google Colab con VS Code

Open sourced by Google Research team, achieved wide popularity amongst NLP enthusiasts for all the right reasons! It is one of the best Natural Language Processing pre-trained models with superior NLP capabilities. It can be used for language classification, question & answering, next word prediction, tokenization, etc. pre-trained models of BERT Our case study Question Answering System in Python using BERT NLP and BERT based Question and Answering system demo , developed in Python + Flask, got hugely popular garnering hundreds of visitors per day. We got a lot of appreciative and lauding emails praising our QnA demo. Along with that, we also got number of people asking about how we created this QnA demo. And till the day, we keep getting requests on how to develop such a QnA system using BERT pre-trained model open-sourced by Google. [1] [2] To start with, the readme file on the official GitHub repository of BERT provides a good amount of information about how to fine-tune the model on SQuAD 2.0 but we could see that developers are still facing issues. So, we decided to publish a step-by-step tutorial to fine-tune the BERT pre-trained model and generate inference of answers from the given paragraph and questions on using TPU. Colab In this tutorial, we are not going to cover how to create web-based interface using Python + Flask. We’ll just cover the fine-tuning and inference on Colab using TPU. You can create your own interface using Flask or Django. Overview In this tutorial we will see how to perform a fine-tuning task on SQuAD using Google Colab, for that we will use BERT GitHub Repository, BERT Repository includes: TensorFlow code for the BERT model architecture. Pre-trained models for both the lowercase and cased version of BERT-Base and BERT-Large. You can also refer or copy to follow the steps. our colab file Steps to perform BERT Fine-tuning on Google Colab 1) Change Runtime to TPU On the main menu, click on and select . Set “ “ as the hardware accelerator. Below screeenshot will help you understand how you can change the runtime to TPU. Runtime Change runtime type TPU After Clicking on “Change runtime type”, Select from the dropdown option as given in the below figure. TPU 2) Clone the BERT github repository , or idirectional mbedding epresentations from ransformers, is a new method of pre-training language representations which obtains state-of-the-art results on a wide array of Natural Language Processing (NLP) tasks. You can find the academic paper here: . BERT B E R T https://arxiv.org/abs/1810.04805 BERT has two stages: and . Pre-training fine-tuning is fairly expensive (four days on 4 to 16 Cloud TPUs), but is a one-time procedure. BERT has released a number of pre-trained models. Most NLP researchers will never need to pre-train their own model from scratch. Pre-training is inexpensive. One can replicate all the results given in the paper, in at most 1 hour on a single Cloud TPU, or a few hours on a GPU. For example, SQuAD can be trained in around 30 minutes on a single Cloud TPU to achieve a Dev F1 score of 91.0%. Fine-tuning So our first step is to Clone the BERT github repository, below is the way by which you can clone the repo from github. Now get inside the Bert repo using “ “ command cd !git clone https: //github.com/google-research/bert.git cd bert 3) Download the BERT PRETRAINED MODEL BERT Pretrained Model List : BERT-Large, Uncased (Whole Word Masking): 24-layer, 1024-hidden, 16-heads, 340M parameters BERT-Large, Cased (Whole Word Masking): 24-layer, 1024-hidden, 16-heads, 340M parameters BERT-Base, Uncased: 12-layer, 768-hidden, 12-heads, 110M parameters BERT-Large, Uncased: 24-layer, 1024-hidden, 16-heads, 340M parameters BERT-Base, Cased: 12-layer, 768-hidden, 12-heads, 110M parameters BERT-Large, Cased: 24-layer, 1024-hidden, 16-heads, 340M parameters BERT-Base, Multilingual Cased (New, recommended): 104 languages, 12-layer, 768-hidden, 12-heads, 110M parameters BERT-Base, Multilingual Uncased (Orig, not recommended): 102 languages, 12-layer, 768-hidden, 12-heads, 110M parameters BERT-Base, Chinese: Chinese Simplified and Traditional, 12-layer, 768-hidden, 12-heads, 110M parameters BERT has released and models, that have uncased and cased version. Uncased means that the text is converted to lowercase before performing Workpiece tokenization, e.g., John Smith becomes john smith, on the other hand, cased means that the true case and accent markers are preserved. BERT-Base BERT-Large When using a cased model, make sure to pass -do_lower=False at the time of training. You can download any model of your choice. We have used the BERT-Large-Uncased Model. !wget https: //storage.googleapis.com/bert_models/2018_10_18/uncased_L-24_H-1024_A-16.zip # Unzip the pretrained model
!unzip uncased_L _H _A zip -24 -1024 -16. 4) Download the SQUAD2.0 Dataset For the Question Answering task, we will be using SQuAD2.0 Dataset. (Stanford Question Answering Dataset) is a reading comprehension dataset, consisting of questions posed by crowdworkers on a set of Wikipedia articles, where the answer to every question is a segment of text, or span, from the corresponding reading passage, or the question might be unanswerable. SQuAD SQuAD2.0 combines the 100,000+ questions in SQuAD1.1 with over 50,000 new, unanswerable questions written adversarially by crowdworkers to look similar to answerable ones. You can download the dataset from SQUAD site https://rajpurkar.github.io/SQuAD-explorer/ #Download the SQUAD train and dev dataset
!wget https: !wget https: //rajpurkar.github.io/SQuAD-explorer/dataset/train-v2.0.json //rajpurkar.github.io/SQuAD-explorer/dataset/dev-v2.0.json 5) Set up your TPU environment Verify that you are connected to a TPU device You will get know your TPU Address which is used at the time of fine-tuning Perform Google Authentication to access your bucket Upload your credentials to TPU to access your GCS bucket Using code below you can do the above mentioned 4 points: datetime json os pprint random string sys tensorflow tf os.environ, TPU_ADDRESS = + os.environ[ ]
print( , TPU_ADDRESS) google.colab auth
auth.authenticate_user() tf.Session(TPU_ADDRESS) session:
  print( )
  pprint.pprint(session.list_devices()) open( , ) f:
    auth_info = json.load(f)
  tf.contrib.cloud.configure_gcs(session, credentials=auth_info) import import import import import import import import as assert 'COLAB_TPU_ADDR' in 'ERROR: Not connected to a TPU runtime; please see the first cell in this notebook for instructions!' 'grpc://' 'COLAB_TPU_ADDR' 'TPU address is => ' from import with as 'TPU devices:' # Upload credentials to TPU. with '/content/adc.json' 'r' as # Now credentials are set for all future sessions on this TPU. 6) Create an output directory : You will need a GCP (Google Compute Engine) account and a GCS (Google Cloud Storage) bucket to run the colab file. Please follow the Google Cloud for how to create a GCP account and GCS bucket. You have $300 free credit to start with any GCP product, learn more about it at . Prerequisite https://cloud.google.com/tpu/docs/setup-gcp-account You can create your GCS bucket from here . http://console.cloud.google.com/storage As we are using the Cloud TPU, we need to store the pre-trained model and the output directory in the Google Cloud Storage. If you are not storing it on Bucket you may face the following error : ERROR:tensorflow: recorded training_loop: From /job:worker/replica: /task: :
Unsuccessful TensorSliceReader : Failed to get matching files on uncased_L-24_H-1024_A-16/bert_model.ckpt: Unimplemented: File system scheme '[local]' not implemented (file: 'uncased_L-24_H-1024_A-16/bert_model.ckpt')
[[node checkpoint_initializer_14 (defined at /usr/local/lib/python3.6/dist-packages/tensorflow_core/python/framework/ops.py:1748) ]] Error from 0 0 constructor You will get your fine_tuned model in the Google cloud storage bucket after completion of training. For that, you need to provide your BUCKET name and OUPUT DIRECTORY name. BUCKET = BUCKET, output_dir_name = BUCKET_NAME = .format(BUCKET)
OUTPUT_DIR = .format(BUCKET,output_dir_name)
tf.gfile.MakeDirs(OUTPUT_DIR)
print( .format(OUTPUT_DIR)) 'bertnlpdemo' #@param {type:"string"} assert '*** Must specify an existing GCS bucket name ***' 'bert_output' #@param {type:"string"} 'gs://{}' 'gs://{}/{}' '***** Model output directory: {} *****' 7) Move Pretrained Model to GCS Bucket Need to move Pre-trained Model at GCS (Google Cloud Storage) bucket, as Local File System is not Supported on TPU. If you don’t move your pre-trained model to TPU you may face the error. The command allows you to move data between your local file system and the cloud, move data within the cloud, and move data between cloud storage providers. gsutil mv !gsutil mv /content/bert/uncased_L _H _A $BUCKET_NAME -24 -1024 -16 8) Training Below is the command to run the training. To run the training on TPU you need to make sure about below Hyperparameter, that is tpu must be true and provide the tpu_address that we have found above. -use_tpu=True -tpu_name=YOUR_TPU_ADDRESS !python run_squad.py \
  --vocab_file=$BUCKET_NAME/uncased_L _H _A /vocab.txt \
  --bert_config_file=$BUCKET_NAME/uncased_L _H _A /bert_config.json \
  --init_checkpoint=$BUCKET_NAME/uncased_L _H _A /bert_model.ckpt \
  --do_train= \
  --train_file=train-v2 .json \
  --do_predict= \
  --predict_file=dev-v2 .json \
  --train_batch_size= \
  --learning_rate= \
  --num_train_epochs= \
  --use_tpu= \
  --tpu_name=grpc:// : \
  --max_seq_length= \
  --doc_stride= \
  --version_2_with_negative= \
  --output_dir=$OUTPUT_DIR -24 -1024 -16 -24 -1024 -16 -24 -1024 -16 True .0 True .0 24 3e-5 2.0 True 10.1 .118 .82 8470 384 128 True Create Testing File We are creating input_file.json as a blank JSON file and then add the data in the file in the SQuAD dataset format. is used to create a file - is used to write a file in the colab - touch %%writefile You can pass your own questions and context in the below file. !touch input_file.json %%writefile input_file.json
{ : , : [
        { : , : [
                { : [
                        { : , : , : },
                        { : , : , : },
                        { : , : , : }
                    ], : }
            ]
        }
    ]
} "version" "v2.0" "data" "title" "your_title" "paragraphs" "qas" "question" "Who is current CEO?" "id" "56ddde6b9a695914005b9628" "is_impossible" "" "question" "Who founded google?" "id" "56ddde6b9a695914005b9629" "is_impossible" "" "question" "when did IPO take place?" "id" "56ddde6b9a695914005b962a" "is_impossible" "" "context" "Google was founded in 1998 by Larry Page and Sergey Brin while they were Ph.D. students at Stanford University in California. Together they own about 14 percent of its shares and control 56 percent of the stockholder voting power through supervoting stock. They incorporated Google as a privately held company on September 4, 1998. An initial public offering (IPO) took place on August 19, 2004, and Google moved to its headquarters in Mountain View, California, nicknamed the Googleplex. In August 2015, Google announced plans to reorganize its various interests as a conglomerate called Alphabet Inc. Google is Alphabet's leading subsidiary and will continue to be the umbrella company for Alphabet's Internet interests. Sundar Pichai was appointed CEO of Google, replacing Larry Page who became the CEO of Alphabet." Prediction Below is the command to perform your own custom prediction, that is you can change the input_file.json by providing your paragraph and questions after then execute the below command. !python run_squad.py \
  --vocab_file=$BUCKET_NAME/uncased_L _H _A /vocab.txt \
  --bert_config_file=$BUCKET_NAME/uncased_L _H _A /bert_config.json \
  --init_checkpoint=$OUTPUT_DIR/model.ckpt \
  --do_train= \
  --max_query_length= \
  --do_predict= \
  --predict_file=input_file.json \
  --predict_batch_size= \
  --n_best_size= \
  --max_seq_length= \
  --doc_stride= \
  --output_dir=output/ -24 -1024 -16 -24 -1024 -16 -10859 False 30 True 8 3 384 128 To make it easier for you, we have already created a Colab file which you can copy in your Google Drive and execute the commands. You can access the colab file at: . Question Answering System using BERT + SQuAD on Colab TPU If you have any further questions or doubt then please feel free to post them in comments. We’ll get back to you. Previously published at https://www.pragnakalp.com/nlp-tutorial-setup-question-answering-system-bert-squad-colab-tpu/ References Our case study Question Answering System in Python using BERT NLP BERT based Question and Answering system demo

NLP Tutorial: Creating Question Answering System using BERT + SQuAD on Colab TPU

How to Structure a PyTorch ML Project With Google Colab and TensorBoard

You have a plain old TensorFlow model that’s too computationally expensive to train on your standard-issue work laptop. I get it. I’ve been there too, and if I’m being honest, seeing my laptop crash twice in a row after trying to train a model on it is painful to watch. In this article, I’ll be breaking down the steps on how to train any model on a TPU in the cloud using Google Colab. After this, you’ll never want to touch your clunky CPU ever again, believe me. TLDR: This article shows you how easy it is to train any TensorFlow model on a TPU with very few changes to your code. What’s a TPU? The Tensor Processing Unit (TPU) is an accelerator — custom-made by Google Brain hardware engineers — that specialises in training deep and computationally expensive ML models. Let’s put things into perspective just to give you an idea of how awesome and powerful a TPU is. A standard MacBook Pro Intel CPU can perform a few operations per clock cycle. A standard off-the-shelf GPU can perform tens of thousands of operations per cycle. A state-of-the-art TPU can perform hundreds of thousands of operations per cycle (sometimes up to 128K OPS). To understand the scale, imagine using these devices to print a book. A CPU can print character-by-character. A GPU can print a few words at a time. A TPU? Well, it can print a whole page at a time. That’s some amazing speed and power that we now have at our disposal; shoutout to Google for giving broke high-schoolers (like me) access to high-performance hardware. If you’re interested in the inner workings of a TPU and what makes it so amazing, go check out the Google Cloud blog article where they discuss everything from hardware to software here . Also, the operations per clock cycle for these devices are rough estimates stated by Google engineers themselves. Please don’t call me out to a duel. Running an MNIST model on TPUs For the sake of this tutorial, I’ll be running through a quick and easy MNIST model. Do note that this model can be whatever you want it to be. To better help you visualise what’s going on, I’ve chosen good old MNIST. Let’s first begin by extracting and preprocessing our dataset. This shouldn’t be much of a problem: numpy np tensorflow tf tensorflow.keras.datasets mnist tensorflow.keras.utils to_categorical

(x_train, y_train), (x_test, y_test) = mnist.load_data() x_train = x_train.reshape(x_train.shape[ ], ) x_train = x_train.astype( )
x_test = x_test.astype( )
x_train /= x_test /= y_train = to_categorical(y_train, )
y_test = to_categorical(y_test, ) (x_train.shape, y_train.shape) (x_test.shape, y_test.shape) import as import as from import from import # preprocessing the dataset 0 1 # 784, 1] 'float32' 'float32' 255 255 10 10 print print # >> (60000, 784), (60000, 10) # >> (10000, 784), (10000, 10) I’ve tried to make this article as comprehensive as possible so that you can train your models at unfathomable speeds and feel like you’re on top of the world. There are 4 steps we will be taking to train our model on a TPU: 1. Connect to a TPU 2. Initialise a parallelly-distributed training strategy 3. Build our model under that strategy 4.Train the model and feel like a Superhero Let’s delve right into it! Note: At times, I’ve heard people say that we need to convert our datasets into TFRecords . Bear in mind that it isn’t necessary and that any dataset can be fed into a model for training on a TPU. Connecting to a TPU When I was messing around with TPUs on Colab, connecting to one was the most tedious. It took quite a few hours of searching online and looking through tutorials, but I was finally able to get it done. For that, we first need to connect our Colab notebook running locally to the TPU runtime. To change runtime, simply click the Runtime tab in the navigation bar. A dropdown menu will be displayed from which you can select the Change runtime type option. A popup window will show up where you can select the TPU option from the dropdown selector. Next, we need to see if any TPUs are available for use: os pprint os.environ:
    print( ) :
    tpu_address = + os.environ[ ] ( , tpu_address) tf.Session(tpu_address) session:
      devices = session.list_devices()

    print( )
    pprint.pprint(devices) import import # for pretty printing our device stats if 'COLAB_TPU_ADDR' not in 'ERROR: Not connected to a TPU runtime; please see the first cell in this notebook for instructions!' else 'grpc://' 'COLAB_TPU_ADDR' print 'TPU address is' with as 'TPU devices:' This should give you a list of 8 devices that can be used to train our models on. It should print something out that looks like this: Initialising a Distributed Training Strategy Now that we’ve changed the runtime and have acquired a list of available TPUs, we need to invoke the TPU by creating a distributed training strategy — a wrapper around the model that makes it compatible with multi-core training. To do so, we need to create a that takes in the available device and provisions one for us. TPUClusterResolver resolver = tf.contrib.cluster_resolver.TPUClusterResolver(tpu= + os.environ[ ])
tf.contrib.distribute.initialize_tpu_system(resolver)
strategy = tf.contrib.distribute.TPUStrategy(resolver) 'grpc://' 'COLAB_TPU_ADDR' The gives us access to the TPU such that we can finally build a parallelly-distributed pipeline on it. This is a necessary step because a TPU is a distributed training processor and is not single-core like a traditional CPU. With this strategy method, jumping on board a TPU is very simple! resolver Building our model under the distributed training strategy With a training strategy now at hand, we can proceed to build our model using that strategy as such: strategy.scope(): model = tf.keras.models.Sequential()
	model.add(tf.keras.layers.Dense( , input_size=[ ,], activation= ))
	model.add(tf.keras.layers.Dense( , activation= ))
	model.add(tf.keras.layers.Dense( , activation= ))
	model.add(tf.keras.layers.Dense( , activation= ))
	model.add(tf.keras.layers.Dense( , activation= )) model.compile(
		optimizer=tf.train.RMSPropOptimizer(learning_rate= ),
		loss=tf.keras.losses.sparse_categorical_crossentropy,
		metrics=[ ]
	)

	model.summary() with """
	Note: This model can be whatever you want it to be.
	Here, I'm building a simple fully-connected network using 
	our distributed training strategy. 
	This essentailly takes our model and makes it 
	compatible to train on a TPU.
	""" 512 784 'relu' 256 'relu' 128 'relu' 64 'relu' 10 'softmax' # compiling the model using the RMSProp optimizer # and Sparse Categorical Crossentropy loss 1e-2 'sparse_categorical_accuracy' This looks like a lot of jargon, but all it does is convert a regular model (that is typically run on a CPU) into a TPU-ready model for distributed training. tf.keras Training our model This is the exciting part of the process. We can finally train our model on a Cloud TPU for free. With so much power in our hands, let’s make good use of it and train on MNIST (I know…very anti-climatic). history = model.fit(x_train,  y_train, epochs= , steps_per_epoch= )
model.save_weights( , overwrite= ) 20 50 './mnist_model.h5' True Ensure that the number of instances is perfectly divisible by the parameter so that all the instances are used during training. For example, we have 60000 instances in our training set. 60000 is divisible by 50 so that means all our instances are fed into the model without any leftovers. steps_per_epoch A final round-up With that, training should commence soon. Colab will boot up a TPU and upload the model architecture on it. You should soon see the classic Keras progress bar style layout in the terminal output. Congrats! You’ve successfully just used a TPU. Introspectively, I always thought training on a TPU was a thing only wizards could handle. TPU training was always that one big thing out of my grasp simply because of the hype around it (making it seem very difficult to use). Never in my wildest dreams did I think it’d be as simple as adding 5–6 lines of code to the preexisting model. After reading this article, I want you to know that anyone can train on accelerated hardware regardless of experience. Some observations about TPU training The Neural Machine Translation model I had written (for the TensorFlow Docs) took me less than a minute to train on a TPU. I was astonished because the same model took more than 4 hours to train on a CPU (which probably explains why my laptop crashed and ran out of memory twice). My model hit a very high accuracy — higher than what I achieved training on a CPU. With performance and speed, the Cloud TPU is second to none when it comes to quality training! Note: You can find my code here . Have fun! In a nutshell Google always comes bearing gifts when it launches new Machine Learning toys that we can tinker and play around with. The TPU processor is certainly a boon to the ML community as it plays a major role in the democratisation of AI — it gives everyone a chance to use accelerated hardware regardless of demographic. With TPUs, research and experimentation are hitting all-time highs and people are now engaging in Machine Learning like never before! I hope this article has helped you train your models in a much more efficient and elegant manner. If you have any questions about the use of TPUs or want to chat in general about Tech and ML, feel free drop them down below in the comments or catch me on or . I usually reply within a day. Twitter LinkedIn Until then, I’ll catch you in the next one! Original article by Rishabh Anand A call to action…of sorts Interested in reading about the latest-and-greatest technologies and getting your hands dirty with the recent happenings in Machine Learning, Data Science, and Technology? Do catch my other articles or give me a follow! Your feedback and constant support mean a lot and encourage me to continue writing high-quality content for your learning! Give me a follow if you love reading about technology, especially Machine Learning and Data Science! You can find me . here

Training Your Models on Cloud TPUs in 4 Easy Steps on Google Colab

This article proposes an easy and free solution to train a Tensorflow model for instance segmentation in Google Colab notebook, with a custom dataset. was about Object Detection in Google Colab with Custom Dataset, where I trained a model to infer bounding box of my dog in pictures. The protagonist of my article is again my dog: in this case we take a step forward, we identify not only the bounding box, we make even pixel wise classification. Previous article Compared to previous article, we hold the same characteristics: Only requirement is the dataset, created with annotation tool A single Google Colab notebook contains all the steps: it starts from the dataset, executes the model’s training and shows inference It runs in Google Colab (GPU enabled environment) and Google Drive storage, so it’s based exclusively on free cloud resources These features allow anybody following this tutorial to create an instance segmentation model, and test it in Google Colab or export the model to run in a local machine. Source code of this article, including the sample dataset, is available in my . Github repo Choosing Framework There are various open source frameworks to implement instance segmentation, you can find an overview in of Stanford University. this presentation We discard solutions that are not based on Tensorflow, such as Facebook Detectron based on Caffe2, because we decided to train the model in Google Colab, that is already integrated with Tensorflow. One of the most popular frameworks, easy to use and well documented, is . From my tests it’s one of the simplest and most robust implementations available. Matterport Mask R-CNN In addition, a big effort I faced with other implementations is to convert the annotations output file to framework input format. To be clear, once you create the pixel annotations of dataset with a graphical tool, you should convert it to input format defined by training framework. Matterport developed this task in a clear , demonstrating how to transform annotations file to Matterport Mask R-CNN format. article Making Dataset In previous article we created bounding box annotations to obtain object detection model, now we are going to train instance segmentation model, therefore we create pixel level mask annotations to define the boundaries of the objects in dataset. Among various available tools, I chose an intuitive and well done tool: by University of Oxford, you can see documentation in the of the project. Furthermore, it’s easy to integrate VIA with Matterport framework. VGG Image Annotator (VIA) official page This tool doesn’t need any installation, you just download the package and open the file with a modern browser. via.html It’s important to create a good dataset to achieve a well performing trained model. Taking pictures of objects with different lighting conditions, from various angles and in different contexts, are good principles to obtain a well generalized model, and avoid overfitting. Dataset of dog At the end of the annotation process, I created “images.zip” file with the following structure: images.zip|- "train" directory|- jpg image files of training data|- "via_region_data.json" annotations file of training data|- "val" directory|- jpg image files of validation data|- "via_region_data.json" annotations file of validation data Lastly I uploaded zip file into Google Drive, to use it during the training and test process. I included the dataset file in my Gitub repo, having pixel wise annotations of dog images. Training Model All the steps are in Google Colab notebook included in my repo. In my example, training process last about half an hour for 5 epochs, to get a more accurate model you can increase the number of epochs and the dataset size. I selected Python3 GPU enabled environment, to use up to 12 hours of Tesla K80 GPU offered in Google Colab. Next steps in notebook are: : install packages, repositories and environment variables for Matterport instance segmentation with Tensorflow. Install required packages : download images.zip dataset in Google Colab filesystem, previously uploaded in Google Drive. Update variable with Google Drive id of your image.zip dataset. Download and extract dataset fileId : code in my repo is inspired by Matterport Splash of Color sample, to run with a different dataset you should replace occurrences of “balloon” and “Balloon” with the name of object. Edit settings file : use pretrained weights to apply transfer learning in training process. Options are COCO and ImageNet. Train model Training process outputs the structure of neural network and various parameters, like the network architecture (Resnet50 or Resnet101). Using TensorFlow backend.Weights:  cocoDataset:  dataset/Logs:  /logs Configurations:BACKBONE                       resnet101BACKBONE_STRIDES               [4, 8, 16, 32, 64]BATCH_SIZE                     2...GPU_COUNT                      1GRADIENT_CLIP_NORM             5.0IMAGES_PER_GPU                 2...Selecting layers to trainfpn_c5p5               (Conv2D)fpn_c4p4               (Conv2D)fpn_c3p3               (Conv2D)fpn_c2p2               (Conv2D)... Below the Tensorboard charts of training process: Tensorboard charts Inference Finally we can run test dataset inference with trained model. Output includes inference data (image resolution, anchors shapes, …), and test images with bounding box, segmentation mask and confidence score. Conclusions If you want to run instance segmentation on a single object class, you can make a few minor changes to my Github code and adapt it to your dataset. I hope you liked this article, in case leave some claps, it will encourage me to write other practical articles about machine learning for computer vision :)

Instance Segmentation in Google Colab with Custom Dataset

It has been a while since I wrote my first tutorial about running deep learning experiments on Google’s GPU enabled Jupyter notebook interface- Colab. Since then, my several blogs have walked through running either Keras, TensorFlow or Caffe on Colab with GPU accelerated. One missing framework not pre-installed on Colab is PyTorch. Recently, I am checking out a video to video synthesis model requires running on Linux, plus there are gigabytes of data and pre-trained model to download before I can take the shiny model for a spin. I was wondering, why not give Colab a try by leveraging its awesome downloading speed and freely available GPU? Enjoy the for this tutorial. Colab notebook link Let’s starts by installing CUDA on Colab. Installing CUDA 9.2 Why not other CUDA versions? Here are three reasons. As of 9/7/2018, CUDA 9.2 is the highest version officially supported by Pytorch seen on its website . pytorch.org Some of you might think to install CUDA 9.2 might conflicts with TensorFlow since TF so far only supports up to CUDA 9.0. Relax, think of Colab notebook as a sandbox, even you break it, it can be reset easily with few button clicks, let along TensorFlow works just fine after installing CUDA 9.2 since I tested. If you install CUDA version 9.0, you might come across when compiling native CUDA extensions for Pytorch. Some sophisticated Pytorch projects contain for custom layers/operations which run faster than their Python implementations. The downside is you need to compile them from source for the individual platform. In Colab case, which is running on an Ubuntu Linux machine, g++ compiler is employed to compile the native CUDA extension. But CUDA version 9.0 has a bug working with g++ compiler to compile native CUDA extensions, that’s why we picked CUDA version 9.2 which got the bug fixed. the issue custom c++ CUDA extensions Back to installing, will ask you for the Ubuntu version where you want to run the CUDA. To find out, run this cell below in a Colab notebook. the Nvidia developer site It returns the information you want. VERSION="17.10 (Artful Aardvark)" After that, you will be able to navigate through the target platform selections, make the installer type , then click on the button to copy the link address. “deb(local)” right “Download (1.2 GB)” Back to Colab notebook, paste the link after a command to download the file. A 1.2GB file only takes about 10 seconds to download on Colab which means there is no coffee break -_-. wget !wget https://developer.nvidia.com/compute/cuda/9.2/Prod2/local_installers/cuda-repo-ubuntu1710-9-2-local_9.2.148-1_amd64 Run the following cell to complete the CUDA installation. If you see those lines at the end of the output, that means the installing was successful. Setting up cuda (9.2.148-1) ...Processing triggers for libc-bin (2.26-0ubuntu2.1) ... Continue with Pytorch. Install PyTorch Very easy, go to , there is a selector for how you want to install Pytorch, in our case, pytorch.org OS: Linux Package Manager: pip Python: , which you can verify by running in a shell. 3.6 python --version CUDA: 9.2 It will let you run this line below, after which, the installation is done! pip3 install torch torchvision Run vid2vid demo Out of the curiosity how well the Pytorch performs with GPU enabled on Colab, let’s try the recently published , a Pytorch implementation of our method for high-resolution photorealistic video-to-video translation. That video demo turns poses to a dancing body looks enticing. Video-to-Video Synthesis demo Besides, the demo also depends on custom built CUDA extensions gives the chance to test out the installed CUDA toolkit. The cell below does all the job from getting the code to running the demo with the pre-trained model. The generated frame goes to directory which you can display one by calling the cell below. results/label2city_1024_g1/test_latest/images That wraps up this tutorial. Conclusion and further thought This short post shows you how to get GPU and CUDA backend running on Colab quickly and freely. Unfortunately, the authors of haven’t got a , which I am anxiously waiting. So far, It only serves as a demo to verify our installing of Pytorch on Colab. Feel free to connect with me on social media where I will keep you posted on my future projects and other practical deep learning applications. Pytorch vid2vid testable edge-face, and pose-dance demo posted yet Here are some of my previous Colab tutorials. ” — My first tutorial on Colab, . “How to run Object Detection and Segmentation on a Video Fast for Free colab notebook direct link ”, — . “Quick guide to run TensorBoard in Google Colab Colab notebook direct link Run caffe-cuda on Colab — . Colab notebook direct link Share on Twitter Share on Facebook Originally published at www.dlology.com .

How to run PyTorch with GPU and CUDA 9.2 support on Google Colab

This article propose an easy and free solution to train a Tensorflow model for object detection in Google Colab, based on custom datasets. To demonstrate how it works I trained a model to detect my dog in pictures. Object Detection with my dog All the code and dataset used in this article is available in . my Github repo Peculiarities of this proposal are: Only requirement is the dataset created with LabelImg A single Google Colab notebook contains all the steps: it starts from the dataset, executes the model’s training and shows inference It runs in Google Colab’s GPU enabled and Google Drive storage, so it’s based exclusively on free cloud resources Furthermore, important changes have recently been made to Tensorflow’s Object Detection api, that made obsolete other available tutorials. Making dataset The only step not included in the Google Colab notebook is the process to create the dataset. With an appropriate number of photos (my example have 50 photos of dog), I created the annotations. The tool I used is . For the sake of simplicity I identified a single object class, my dog. It’s possible to extend it to obtain models that perform object detection on multiple object classes. LabelImg I renamed the image files in the format (i.e. dog_001.jpg, dog_002.jpg). Then in LabelImg, I defined the bounding box where the object is located, and I saved annotations in Pascal Voc format. objectclass_id.jpg Finally I uploaded annotations files in my Google Drive account, using a single zip file with the following structure: .zip file|-images directory|-image files (filename format: objectclass_id.jpg)|-annotations directory|-xmls directory|-annotations files (filename format: objectclass_id.xml) Check my dataset file in Github to see an example. Dataset example Model training All the next steps are included in the Google Colab notebook. I execute cells in sequence to train the model and run inference: install packages, repositories and environment variables for object detection in Tensorflow, then run a test. Install required packages: download in the filesystem the dataset created. It’s important that the zip file has the structure explained above. Download and extract dataset: this is a cell to avoid error in create_pet_tf_record.py, it has not any effect in training process. Empty png files: from the dataset it creates the TFRecord. In this simplified version, algorithm will train model only for one class. Create TFRecord: download pretrained model from ModelZoo as initial checkpoint for transfer learning. In the example we download the model faster_rcnn_inception_v2_coco, to use another model from ModelZoo change var. Download pretrained model: MODEL MODEL = 'faster_rcnn_inception_v2_coco_2018_01_28'MODEL_FILE = MODEL + '.tar.gz'DOWNLOAD_BASE = 'http://download.tensorflow.org/models/object_detection/'DEST_DIR = 'pretrained_model' set the fields of the config file, identified by . If you choose a different initial checkpoint model, update accordingly filename var and re.sub functions in the cell. Edit model config file: PATH_TO_BE_CONFIGURED this is the main step, it performs the train of the model with the data and the configurations so far created. It is possible to change the number of steps in train and in validation. Train model: Below the Tensorboard charts resulting from training process: Tensorboard charts Inference export model to run inference. The cell converts last trained model to the format to run inference. Export trained model: browser upload of test image file to run inference in the next step. Upload image for inference: finally it performs inference of the uploaded image, and shows the result below. Run inference: Next goals Thanks a lot for reading my article. In this article we easily trained an object detection model in Google Colab with custom dataset, using Tensorflow framework. If you liked, leave some claps, I will be happy to write more about machine learning. In next articles we will extend the Google Colab notebook to: Include of object detection multiple classes View in a different browser tab during model training Tensorboard Perform to do pixel wise classification instance segmentation

Object Detection in Google Colab with Custom Dataset

Vor kurzem erst entdeckt und für gut befunden: Googles Plattform um schnell mal Scripts zu erstellen und in Form eines Jupyter Notebooks verwalten. Alle Möglichkeiten sind unter: ersichtlich. Ausgaben über die , Nutzung von , installieren weiterer Libs über und und und. Python https://colab.research.google.com matplotlib NumPy pip Zur Nutzung benötigt man eine Einladung. Beim Aufruf des o.g. Links wird man darauf hingewiesen und kann eine Einladung anfordern. Bei mir hat das keine 24 Stunden gedauert. Einfach mal ausprobieren. Hier mal ein Beispielnotebook von mir: Webscraping mit Python und BeautifulSoup Momentan ist (leider) nur Python 2.7.x verfügbar. Für eine _Jupyter_artige Arbeit aber auf jeden Fall mehr als empfehlenswert. Besonders die nahtlose Integration in finde ich super. Man kann aus Drive heraus einfach ein neues Notebook erstellen und natürlich auch den Link dazu wie bei Google Drive für andere Dateien gewohnt, freigeben und teilen. Tolle Sache. Google Drive Google Hoffen wir mal, dass dieses Produkt weiterentwickelt und gepflegt wird. Man weiß ja, dass Google schnell mal bestehende Produkte beerdigt. Hier will Google aber die Möglichkeiten des oder auf eine einfache Plattform heben. Deshalb bin ich optimistisch, dass dieses Projekt nicht eingestampft wird. Machine Learning Deep Learning Daumen hoch dafür! Anregungen, Korrekturen und weitere Meinungen wie immer Willkommen! Stay tuned. :-) Postet on mosenturm.de

Colaboratory — Google — Research at Google — am Beispiel Webscraping mit Python

164 Stories To Learn About Nlp

128 Stories To Learn About Natural Language Processing

Scratching the Singularity Surface: The Past, Present and Mysterious Future of LLMs

Rascando la superficie de la singularidad: el pasado, el presente y el futuro misterioso de los LLM

Gratter la surface de la singularité : le passé, le présent et l'avenir mystérieux des LLM

सिंगुलैरिटी सरफेस स्क्रैचिंग: द पास्ट, प्रेजेंट एंड मिस्टीरियस फ्यूचर ऑफ एलएलएम

特異点の表面をひっかく: LLM の過去、現在、そして神秘的な未来

Arranhando a superfície da singularidade: o passado, o presente e o futuro misterioso dos LLMs

Làm trầy xước bề mặt điểm kỳ dị: Quá khứ, hiện tại và tương lai bí ẩn của LLM

探索奇点表面：法学硕士的过去、现在和神秘的未来

Modern applications often incorporate search solutions to enable users to quickly access existing content on demand. It is difficult to envision any other functionality that could efficiently retrieve this information, making search an essential feature in most applications. Custom-made search solution options Simultaneously, even if the need to query and search is very common, different applications take drastically different approaches. In most cases, companies remain at a very basic level of search by simply querying OLTP databases directly. Requests may look like this: . SELECT id, title FROM, entities WHERE, description LIKE ‘%bow% However, more frequently, they are represented in complex, multiple-level table join structures which are impossible to read, slow, and primitive. They are unable to comprehend context, require numerous customizations, and are very challenging to implement properly. While it is possible to improve query execution time through materialized views, query caching, and other technics, the added complexity results in a considerable lag between primary updates and consistent search results. More efficient alternatives to primitive DB-based search solutions may constitute open-source search engines such as Apache Lucene, Apache Solr, Elasticsearch, Sphinx, MeiliSearch, Typesense, etc. These tend to be comparatively faster and much better at dealing with complex queries and working with filters. But once these search engines are compared to counterparts like Search or DuckDuckGo, it becomes clear that open-source solutions fail at building proper search context and query modalities — they are incapable of understanding a query if the user provides a vague search request. Google Extracting the meaning from the query Imagine you simply cannot remember what that yellow citrus fruit with a sour taste are called! But you want to search the app for an article on how to grow this mysterious fruit. How do you go about that search? Your query may be, “How to grow yellow sour citrus indoors”. Any of the aforementioned open-source search engines may struggle significantly to return relevant results for this query, even if the database does contain articles about growing “lemons”. That is because the extraction of meaning from a query is a natural language task and is unlikely to be solved without AI components. is good at this task. GPT-3 OpenAI offers based on GPT-3 that converts natural language text into a vector of floating point numbers. An embedding is essentially a low-dimensional space into which high-dimensional vectors can be translated. In this case, the high-dimensional vector is text and the low-dimensional is an output vector of fixed size. The distance between vectors represents how strongly they correlate. The smaller the distance, the higher the correlation. By redefining text as a vector-based form, the task is reduced to a classical ML search problem. an embeddings API Choosing the right model The conversion of document text into a vector representative can happen in the background, while the vectorization of the search query should occur during runtime. There are several GPT-3 model families that OpenAI offers: text-search-ada-doc-001: 1024
text-search-babbage-doc-001: 2048
text-search-curie-doc-001: 4096
text-search-davinci-doc-001: 12288 Higher vector dimensions lead to more embedded information and, thus, also higher costs and slower searches. Documents are usually long and queries are generally short and incomplete. Therefore, the vectorization of any document differs significantly from any query’s vectorization considering the content’s density and size. OpenAI know that, and so they offer two paired models, and : -doc -query text-search-ada-query-001: 1024
text-search-babbage-query-001: 2048
text-search-curie-queryc-001: 4096
text-search-davinci-query-001: 12288 It is important to note that the query and document must both utilize the same model family and have the same length of the output vector. Example dataset It may be easiest to observe and understand the power of this search solution through examples. For this example, let us draw on the which contains metadata about roughly 5,000 movies from TMDb. We will build a search solution relying only on movie documents, not reviews. TMDB 5000 Movie Dataset The dataset contains plenty of columns, but our vectorization process will be built around the title and overview columns only. Example of the record: Title: Harry Potter and the Half-Blood Prince

Overview: As Harry begins his sixth year at Hogwarts, he discovers an old book marked as 
‘Property of the Half-Blood Prince’, and begins to learn more about Lord Voldemort’s dark past. Let’s map the dataset into ready-to-indexing text: datafile_path = "./tmdb_5000_movies.csv"
df = pd.read_csv(datafile_path)

def combined_info(row):
  columns = ['title', 'overview']
  columns_to_join = [f"{column.capitalize()}: {row[column]}" for column in columns]
  return '\n'.join(columns_to_join)

df['combined_info'] = df.apply(lambda row: combined_info(row), axis=1) The embedding process is straightforward: def get_embedding(text, model="text-search-babbage-doc-001"):
   text = text.replace("\n", " ")
   return openai.Embedding.create(input = [text], model=model)['data'][0]['embedding']

get_embedding(df['combined_info'][0]) This block of code outputs a list the size of which is equal to the parameters that the model is operating with, which in the case of is 2048. text-search-babbage-doc-001 A similar embedding process should be applied to all documents we would like to search on: df['combined_info_search'] = df['combined_info'].apply(lambda x: get_embedding(x, model='text-search-babbage-doc-001'))
df.to_csv('./tmdb_5000_movies_search.csv', index=False) Column will hold a vector representation of the combined_text. combined_info_search And, surprisingly, that’s already it! Finally, we are ready to perform a sample search query: from openai.embeddings_utils import get_embedding, cosine_similarity

def search_movies(df, query, n=3, pprint=True):
    embedding = get_embedding(
        query,
        engine="text-search-babbage-query-001"
    )
    df["similarities"] = df.combined_info_search.apply(lambda x: cosine_similarity(x, embedding))

    res = (
        df.sort_values("similarities", ascending=False)
        .head(n)
        .combined_info
    )
    if pprint:
        for r in res:
            print(r[:200])
            print()
    return res


res = search_movies(df, "movie about the wizardry school", n=3) These are the results we get: Title: Harry Potter and the Philosopher’s StoneOverview: Harry Potter has lived under the stairs at his aunt and uncle’s house his whole life. But on his 11th birthday, he learns he’s a powerful wizard — with a place waiting for him at the Hogwarts School of Witchcraft and Wizardry. As he learns to harness his newfound powers with the help of the school’s kindly headmaster, Harry uncovers the truth about his parents’ deaths — and about the villain who’s to blame.

Title: Harry Potter and the Goblet of FireOverview: Harry starts his fourth year at Hogwarts, competes in the treacherous Triwizard Tournament and faces the evil Lord Voldemort. Ron and Hermione help Harry manage the pressure — but Voldemort lurks, awaiting his chance to destroy Harry and all that he stands for.

Title: Harry Potter and the Prisoner of AzkabanOverview: Harry, Ron and Hermione return to Hogwarts for another magic-filled year. Harry comes face to face with danger yet again, this time in the form of an escaped convict, Sirius Black — and turns to sympathetic Professor Lupin for help. The overview for ‘ ’ contains the words ‘wizardry’ and ‘school’ and comes first in the search output. The second result no longer contains the word ‘school’, but still retains words close to ‘wizardry’, ‘Triwizard’. The third result contains only a synonym of ‘wizardry’ — magic. Harry Potter and the Philosopher’s Stone There are, of course, a multitude of other movies within this database that feature schools or wizards (or both), but the above were the only ones returned to us. This is clear proof that the search solution works and actually understood the context of our query. We used the Babbage model with only 2048 parameters. Davinci has six times more (12,288) parameters and can, thus, perform significantly better with regard to highly complex queries. The search solution may occasionally fail to produce output relevant to some queries. For instance, the query ‘movies about wizards in school’ produces: Title: Harry Potter and the Philosopher’s StoneOverview: Harry Potter has lived under the stairs at his aunt and uncle’s house his whole life. But on his 11th birthday, he learns he’s a powerful wizard — with a place waiting for him at the Hogwarts School of Witchcraft and Wizardry. As he learns to harness his newfound powers with the help of the school’s kindly headmaster, Harry uncovers the truth about his parents’ deaths — and about the villain who’s to blame.

Title: Dumb and Dumberer: When Harry Met LloydOverview: This wacky prequel to the 1994 blockbuster goes back to the lame-brained Harry and Lloyd’s days as classmates at a Rhode Island high school, where the unprincipled principal puts the pair in remedial courses as part of a scheme to fleece the school.

Title: Harry Potter and the Prisoner of AzkabanOverview: Harry, Ron and Hermione return to Hogwarts for another magic-filled year. Harry comes face to face with danger yet again, this time in the form of an escaped convict, Sirius Black — and turns to sympathetic Professor Lupin for help. What is ‘Dumb and Dumberer: When Harry Met Lloyd’ doing here you may wonder? Thankfully, this issue was not reproduced on parameters with more parameters. Calculating the distance between the query and documents The search output should consist of documents sorted in descending order by relevance. To achieve this, we should be aware of the distance between the current query and each document. The shorter the length, the comparatively more relevant the output. Then, after a defined maximum reach, we should stop considering the relevance of the remaining documents. In the aforementioned example, we used to calculate distance due to the high dimensionality of the vector space. With the babbage model, we have 2048 parameters. cosine similarity Distance calculation algorithms tend to represent this similarity (difference) between a query and a document with a single number. However, we cannot rely on the because of the — distances will be too similar. This is because Euclidean distance becomes highly impractical beyond around seven dimensions — at this point, distances fall into the same buckets and become almost identical. Euclidean distance curse of dimensionality If you would like, you may check out the resulting repository here: https://github.com/weblab-technology/gpt3-embeddings-movies-search?embedable=true Alternatively, you can play with it in Google Colab . here Time complexity We used the brute force approach to sort the documents. Let’s determine: ● n: number of points in the training dataset ● d: data dimensionality The search time complexity for brute force solutions is . Parameter depends on the model (in the case of Babbage, it is equal to 2048) while we have block due to the sorting step. O(n * d * n * log(n)) d O(nlog(n)) It is critical to remind ourselves at this stage that smaller models are faster and cheaper. For instance, in the search case similarity calculation step, the Ada model is two times faster, while the Davinci model is six times slower. Cosine similarity calculations between the query and 4803 documents of 2048 dimensions took 1260 ms on my M1 Pro. In the current implementation, time required to calculate would grow linearly to the total number of documents. Simultaneously, this approach supports computation parallelization. Alternatives to the brute force solution In search solutions, queries should be completed as quickly as possible. And this price is usually paid on the side of training and pre-caching time. We can use data structures like a k-d tree, r-tree, or ball tree. Consider the article from about the computational complexity analysis of these methods: They all lead to computational complexity close to , where is the number of elements we would like to return within a single batch. Towards Data Science O(k * log(n)) k K-d trees, ball trees, and r-trees constitute data structures that are used to store and efficiently search for points in N-dimensional space, such as our meaning vectors. K-d and ball trees are tree-based data structures that use an iterative, binary partitioning scheme to divide the space into regions, with each node in the tree representing a subregion. K-d trees are particularly efficient at searching for points within a specific range or finding the nearest neighbor to a given point. Similarly, r-trees are also used to store points in N-dimensional space, however, they are much more efficient at searching for points within a specific region or finding all points within a certain distance of a given point. Importantly, r-trees use a different partitioning scheme to k-d trees and ball trees; they divide the space into ‘rectangles’ rather than binary partitions. Tree implementations fall outside the scope of this article, and different implementations will lead to different search outputs. Query time Perhaps, the most significant disadvantage of the current search solution is that we must call an external OpenAI API to retrieve the query embedding vector. No matter how quickly our algorithm is able to find the nearest neighbors, a sequential blocking step will be required. Text-search-babbage-query-001
Number of dimensions: 2048
Number of queries: 100
Average duration: 225ms
Median duration: 207ms
Max duration: 1301ms
Min duration: 176ms Text-search-ada-query-002
Number of dimensions: 1536
Number of queries: 100
Average duration: 264ms
Median duration: 250ms
Max duration: 859ms
Min duration: 215ms Text-search-davinci-query-001
Number of dimensions: 12288
Number of queries: 100
Average duration: 379ms
Median duration: 364ms
Max duration: 1161ms
Min duration: 271ms If we take the median as a referencing point, we can see that ada-002 is +28% slower and davinci-001 is +76% slower. Limitations of GPT-3 Search Embedding Referring to , we may conclude that GPT-3 does not provide an exceptional performance or output quality and requires dependence on external API that is rather slow. GPT-3 has the capability to support inputs of up to 4096 tokens (approximately 3072 words), however, there is no truncation service available through the API and attempting to encode text longer than 4096 tokens will result in an error. Thus, it is the responsibility of the user — you — to determine how much text can actually be encoded. Nils Reimer’s article about dense text embeddings model comparison Also, training costs are relatively high with OpenAI. Alternatively, you may consider trying or . TAS-B multi-qa-mpnet-base-dot-v1 Approximate nearest neighbor search in Elasticsearch Elasticsearch 8.0 supports efficient approximate nearest neighbor search (ANN) that may be used to solve our problem magnitudes faster than any linear KNN could. Elasticsearch 8.0 utilizes an ANN algorithm called Hierarchical Navigable Small World graphs (HNSW) to organize vectors into graphs based on similarity. Tested on a dataset of 10 million embedded vectors, we achieved an impressive performance of 200 queries per second with ANN on a single compute-focused machine, while only 2 queries per second using KNN. Both were provided by Elasticsearch. According to ElasticSearch’s and the , the cost of this performance is 5% of recall. This means that around 1 in 10 of the closest vectors found are not genuinely relative. We applied a hybrid approach to improve this result: Request k+l instead of k and apply filtering to remove outliers. Sadly, there are no pagination capabilities. So, this approach will only work in some use cases. blog post about the ANN release benchmark for dense vector searches As you will have hopefully seen, GPT-3 Embeddings is not the perfect solution for any and all search problems due to its indexing complexity, cost, as well as the high computational complexity of the search operation, even of approximates. Nevertheless, GPT-3 Embeddings remains an excellent choice for anyone looking for a powerful backbone for a search solution with infrequent querying and modest indexing requirements. Moreover, it’s also worth adding that recently that the Bing search engine now uses the new upgraded version of GPT 3.5, called ‘Prometheus’ and developed initially for search. According to the announcement, the new Prometheus language model allows Bing to increase relevance, more accurately annotate snippets, provide fresher results, understand geolocation and improve security. This may open up new possibilities for using the autoregressive language model for search solutions, which we will definitely keep an eye on going forward. Microsoft announced References: New and Improved Embedding Model k nearest neighbors computational complexity scipy.spatial.KDTree k-d tree OpenAI GPT-3 Text Embeddings — Really a new state-of-the-art in dense text embeddings? Introducing approximate nearest neighbor search in Elasticsearch 8.0 About the author Oleksandr Knyga is a Solution Architect and open-source believer with a big passion for Software Development. Oleksandr lives the life of a digital nomad. When not tapping on the keyboard, he can be found hiking, snowboarding, fishing, and exploring the city. Oleksandr has an MBA and a Computer Science Master’s degree. Also published here.

Harnessing GPT-3 for Improved Search Solutions

Aprovechar GPT-3 para mejorar las soluciones de búsqueda

Exploiter GPT-3 pour améliorer les solutions de recherche

बेहतर खोज समाधानों के लिए GPT-3 का उपयोग करना

GPT-3 を利用して検索ソリューションを改善する

Aproveitando o GPT-3 para soluções de pesquisa aprimoradas

Khai thác GPT-3 cho các giải pháp tìm kiếm được cải thiện

利用 GPT-3 改进搜索解决方案

In this tutorial, we fine-tune a model for topic classification using the Hugging Face Transformers and Datasets libraries. By the end of this tutorial, you will have a powerful fine-tuned model for classifying topics and published it to Hugging Face 🤗 for people to use. RoBERTa Prerequisites This article assumes you have a 🤗 account and working Python, NLP, and Deep learning knowledge. Hugging Face : A basic understanding of machine learning concepts, such as supervised learning, training, and evaluation. Understanding of machine learning concepts will help follow the code presented in the tutorial. Python programming experience : Some experience with deep learning and natural language processing (NLP) concepts, such as neural networks, word embeddings, and tokenization, will be beneficial for grasping the ideas presented in the tutorial. Familiarity with deep learning and natural language processing . Access to a Google Colab or Jupyter Notebook environment : To publish your fine-tuned model to the Hugging Face Hub, you will need a Hugging Face account. If you do not already have an account, you can sign up for one at . A Hugging Face account https://huggingface.co/join By meeting these prerequisites, you will be well-prepared to follow the tutorial and get the most out of it. Let's get our hands dirty 😁 We start by installing the dependencies. !pip install transformers datasets huggingface_hub tensorboard==2.11
!sudo apt-get install git-lfs --yes We then import the needed modules. import torch
from datasets import load_dataset
from transformers import (
    RobertaTokenizerFast,
    RobertaForSequenceClassification,
    TrainingArguments,
    Trainer,
    AutoConfig,
)
from huggingface_hub import HfFolder, notebook_login We need to log in to Hugging Face by using a token. notebook_login() Let's set some variables for easier configuration. model_id = "roberta-base"
dataset_id = "ag_news"
# relace the value with your model: ex <hugging-face-user>/<model-name>
repository_id = "achimoraites/roberta-base_ag_news" Preprossessing Next, we load our dataset and do some preprocessing. # Load dataset
dataset = load_dataset(dataset_id)

# Training and testing datasets
train_dataset = dataset['train']
test_dataset = dataset["test"].shard(num_shards=2, index=0)

# Validation dataset
val_dataset = dataset['test'].shard(num_shards=2, index=1)

# Preprocessing
tokenizer = RobertaTokenizerFast.from_pretrained(model_id)

# This function tokenizes the input text using the RoBERTa tokenizer. 
# It applies padding and truncation to ensure that all sequences have the same length (256 tokens).
def tokenize(batch):
    return tokenizer(batch["text"], padding=True, truncation=True, max_length=256)

train_dataset = train_dataset.map(tokenize, batched=True, batch_size=len(train_dataset))
val_dataset = val_dataset.map(tokenize, batched=True, batch_size=len(val_dataset))
test_dataset = test_dataset.map(tokenize, batched=True, batch_size=len(test_dataset)) Set The Dataset Format The function is used to specify the dataset format, making it compatible with PyTorch. set_format() The argument lists the columns that should be included in the formatted dataset. columns In this case, the columns are "input_ids", "attention_mask", and "label". By setting the format and specifying the relevant columns, we prepare the datasets for use with the Hugging Face Trainer class, which requires PyTorch tensors as input. # Set dataset format
train_dataset.set_format("torch", columns=["input_ids", "attention_mask", "label"])
val_dataset.set_format("torch", columns=["input_ids", "attention_mask", "label"])
test_dataset.set_format("torch", columns=["input_ids", "attention_mask", "label"]) To make our model easier to use, we will create an mapping. This will map the class ids to their labels. id2label This makes it easier to interpret the model’s output during inference. # We will need this to directly output the class names when using the pipeline without mapping the labels later.
# Extract the number of classes and their names
num_labels = dataset['train'].features['label'].num_classes
class_names = dataset["train"].features["label"].names
print(f"number of labels: {num_labels}")
print(f"the labels: {class_names}")

# Create an id2label mapping
id2label = {i: label for i, label in enumerate(class_names)}

# Update the model's configuration with the id2label mapping
config = AutoConfig.from_pretrained(model_id)
config.update({"id2label": id2label}) Training and Evaluation Now, we will set up our training parameters, Hugging Face 🤗 repository, and Tensorboard. # TrainingArguments
training_args = TrainingArguments(
    output_dir=repository_id,
    num_train_epochs=5,
    per_device_train_batch_size=8,
    per_device_eval_batch_size=8,
    evaluation_strategy="epoch",
    logging_dir=f"{repository_id}/logs",
    logging_strategy="steps",
    logging_steps=10,
    learning_rate=5e-5,
    weight_decay=0.01,
    warmup_steps=500,
    save_strategy="epoch",
    load_best_model_at_end=True,
    save_total_limit=2,
    report_to="tensorboard",
    push_to_hub=True,
    hub_strategy="every_save",
    hub_model_id=repository_id,
    hub_token=HfFolder.get_token(),
)

# Trainer
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_dataset,
    eval_dataset=val_dataset,
) We can start the training process by running: # Fine-tune the model
trainer.train() Evaluate the model: # Evaluate the model
trainer.evaluate() Publishing We are ready to publish our model to Hugging Face 🤗 # Save our tokenizer and create a model card
tokenizer.save_pretrained(repository_id)
trainer.create_model_card()
# Push the results to the hub
trainer.push_to_hub() Test The Model At this point, our model should have been published and will be available for use. Let's test it! # TEST MODEL

from transformers import pipeline

classifier = pipeline('text-classification',repository_id)

text = "Kederis proclaims innocence Olympic champion Kostas Kederis today left hospital ahead of his date with IOC inquisitors claiming his innocence and vowing: quot;After the crucifixion comes the resurrection. quot; .."
result = classifier(text)

predicted_label = result[0]["label"]
print(f"Predicted label: {predicted_label}") Congratulations You have fine-tuned and published a RoBERTa model for text classification using Hugging Face 🤗 transformers and datasets libraries! **For reference, here is my fine-tuned model on Hugging Face 🤗
\ https://huggingface.co/achimoraites/roberta-base_ag_news **You can find the code here
\ https://github.com/achimoraites/machine-learning-playground/blob/main/NLP/Text classification/RoBERTa_Finetuning.ipynb Happy 🤖 learning 😀! Also published here Feature image: Photo by Vlada Karpovich from Pexels: https://www.pexels.com/photo/crop-young-businesswoman-using-laptop-while-drinking-tea-at-home-4050347/

Fine-Tuning RoBERTa for Topic Classification

I’ve always wanted to learn how to separate vocals from a track programmatically and not depend on software-as-a-service to perform the task for me. This article illustrates how to separate the vocals of a song from the instruments using my new favorite library, Librosa. You can check out the . Google Colab Notebook here The idea sparked when I wanted to separate individual tracks of a song I really liked, so I went to Product Hunt and discovered . This discovery started the urge to learn ML for music, and the eventual discovery of the Python library, librosa. melody ml By the way, I ran out of , which made my notebook . RAM explode https://twitter.com/tonypoppinss/status/1620369862630739968?embedable=true Install and import dependencies pip install librosa matplotlib IPython

import librosa
from librosa import display
import numpy as np
import IPython.display as ipd
import matplotlib as plt Load and display the song. I used as I wondered how the or parts of the song would come out. My Last Serenade by KSE growling shouting y, sr = librosa.load('My Last Serenade.wav')
ipd.Audio(data=y[90*sr:110*sr], rate=sr) We slice a 20-second snippet in the chorus of the song. We show the audio using . The photo is shown below because I couldn't find a way to upload audio here on DEV. ipd.Audio (tbh, this is a bit exhausting) We separate a complex-valued spectrogram D into its magnitude (S) and phase (P) components, convert the time stamps into frames, plot the data, then display the full spectrogram of the data. S_full, phase = librosa.magphase(librosa.stft(y))
idx = slice(*librosa.time_to_frames([90*110], sr=sr))
fig, ax = plt.pyplot.subplots()
img = display.specshow(librosa.amplitude_to_db(S_full[:, idx], ref=np.max), y_axis='log', x_axis='time', sr=sr, ax=ax)
fig.colorbar(img, ax=ax) Line-by-line explanation - we separate the magnitude and phase of the track using by representing a signal in the time-frequency domain by computing discrete Fourier Transforms(DFT) S_full, phase = librosa.magphase(librosa.stft(y)) short-time Fourier transform (y) - slice the part of the song then convert it to stft frames using the function of librosa. idx = slice(*librosa.time_to_frames([90*110], sr=sr)) time_to_frames - display the spectrogram of the 20-second sliced part of the song by converting the amplitude spectrogram to a dB-scaled spectrogram of the magnitude, then compares the magnitude and phase of the track and returns a new array containing the element-wise maxima and finally it plots the and -axes. img = display.specshow(librosa.amplitude_to_db(S_full[:, idx], ref=np.max), y_axis='log', x_axis='time', sr=sr, ax=ax) y x Below is the image of the spectrum: Decomposing the spectrogram S_filter = librosa.decompose.nn_filter(S_full, aggregate=np.median, metric='cosine', width=int(librosa.time_to_frames(2, sr=sr)))
S_filter = np.minimum(S_full, S_filter) Line-by-line explanation - we filter the vocals by their nearest neighbors, aggregate their median values, compare their frames using cosine similarity and contain those frames to be separated by 2 seconds and suppress other sounds from the spectrum S_filter = librosa.decompose.nn_filter(S_full, aggregate=np.median, metric='cosine', width=int(librosa.time_to_frames(2, sr=sr))) - we get the calculated data in the memory of the and variables to get the minimum value. S_filter = np.minimum(S_full, S_filter) S_full S_filter Display the background and foreground spectrum of the audio margin_i, margin_v = 3, 11
power = 3

mask_i = librosa.util.softmask(S_filter, margin_i * (S_full - S_filter), power=power)
mask_v = librosa.util.softmask(S_full - S_filter, margin_v * S_filter, power=power)

S_foreground = mask_v * S_full
S_background = mask_i * S_full Line-by-line explanation - we use margins to reduce loss in sound in the vocals and instrumented masks margin_i, margin_v = 3, 11 - returns the soft mask computed in a numerically stable way power = 3 and - multiply the masks with the input spectrum to separate the components S_foreground = mask_v * S_full S_background = mask_i * S_full Plotting the full spectrum, background and foreground spectrum fig, ax = plt.pyplot.subplots(nrows=3, sharex=True, sharey=True)
img = display.specshow(librosa.amplitude_to_db(S_full[:, idx], ref=np.max), y_axis='log', x_axis='time', sr=sr, ax=ax[0])
ax[0].set(title='Full Spectrum')
ax[0].label_outer()

display.specshow(librosa.amplitude_to_db(S_background[:, idx], ref=np.max), y_axis='log', x_axis='time', sr=sr, ax=ax[1])
ax[1].set(title='Background Spectrum')
ax[1].label_outer()

display.specshow(librosa.amplitude_to_db(S_foreground[:, idx], ref=np.max), y_axis='log', x_axis='time', sr=sr, ax=ax[2])
ax[2].set(title='Foreground Spectrum')
ax[2].label_outer()

fig.colorbar(img, ax=ax) Recover the foreground audio from the masked spectrogram and playback the audio y_foreground = librosa.istft(S_foreground * phase)
ipd.Audio(data=y_foreground[90*sr:110*sr], rate=sr) Line-by-line explanation - inverses the short-time fourier transform - plays back the vocals from the track y_foreground = librosa.istft(S_foreground * phase) ipd.Audio(data=y_foreground[90*sr:110*sr], rate=sr) Conclusion This seemed easy at first thought and when I was reading the documentation but digging under the code made me realize that this idea was a little more complex. But, what made me continue was when I read about in one part of the documentation which made me realize that I will be getting my hands dirty with Machine Learning in the future with this library. nearest neighbors Also published . here

How to Isolate Vocals in a Song With Python

As data scientists, we often would like to start training models as soon as possible. And that is not just because humans are impatient by nature. For example, we might want to test a very small change in someone’s project and we would like to avoid a lengthy setup phase just to test such a minor modification. That is especially apparent when working with computer vision and large image datasets. Were you ever annoyed when you had to pull a massive dataset (versioned using DVC) before training your model? Or maybe you had to pull the entire dataset just to inspect/modify a single image or a few of them? If that sounds familiar, I will show you how to solve those potential bottlenecks using DagsHub’s new data streaming client. What is the data streaming client? DagsHub’s open-source streaming client is called and essentially it allows to stream data from any DagsHub repository. In other words, our Python code will act as if all the files exist locally, but in reality, the client will dynamically download them on request. Additionally, we can also upload the data to any project hosted on DagsHub. But most importantly, using the streaming client does not require making extensive changes to our codebase. One or two additional lines of code are often enough to fully enjoy the benefits of the new client. Direct Data Access (DDA) In a nutshell, DDA offers the following: the ability to stream data in batches from any DagsHub repository, appending new data to existing datasets without pulling the entire dataset first, smart caching - files remain available after they are streamed, saving time, resources, and memory. After the high-level overview of the new client, let’s dive a bit deeper into how it actually works. Under the hood, there are two main implementations of DDA. The first one employs and it detects any calls to Python’s built-in file operations (such as , , etc.) and modifies them to retrieve the files from the DagsHub repository if they are not found locally. The biggest advantage of this approach is that most of the popular Python libraries will automatically work with this method. Python Hooks open write While this already sounds great, we should be aware of some limitations of this approach: The method will not work with frameworks that rely on I/O routines written in C/C++, for example, OpenCV. DVC commands such as and for stages that have DCV-tracked files in won’t work. dvc repro dvc run deps The second implementation is called and it is based on . Behind the scenes, the client creates a virtual mounted filesystem reflecting our DagsHub repository. That filesystem behaves like a part of our local filesystem, for example, we see all the files in the directory and we can view them. Mounted Filesystem FUSE (Filesystem in USErspace) As always, the burning question is which implementation to use. The documentation suggests that if you are working on a Windows or Mac and do not have any frameworks/libraries relying on C, use the Python Hooks approach. Otherwise, use the Mounted Filesystem. Please refer to for a comprehensive comparison of the two approaches. the documentation Use cases of the streaming client We already know what the streaming client is and how it works. Let’s now cover a few of its potential use cases to show how we can use it in our workflows. First and foremost, we can use it to reduce the time needed to start a training run. Let’s imagine we are working with an image classification problem. With the streaming client, we do not have to download the entire dataset before we actually start training a model, as Python will pretend that the files are already available and start training the models immediately. Data loaders are frequently optimized to load the next batch while the current one is being used for training. In the background, the streaming client will simply download images in batches as they are requested for training and cache them for later use. With this approach, we can potentially save a lot of time and resources. The latter can be measured by, for example, the runtime of a virtual machine. Second, we can train our models only on subsets of the entire dataset. Imagine having a dataset with images from thousands of classes, but for your particular experiment, you only want to train using a few of the selected categories. With the streaming client, your Python code will only load the data that is actually requested for training. Lastly, we can also use the streaming client to upload data to our DVC-versioned repositories. In an especially frustrating scenario, we might have tens of thousands of images in our dataset and we would like to add 10 more images that we gathered. Normally, we would have to pull all the data, add the new images and version the entire modified dataset again. With DDA, we can just directly add the 10 new images without downloading the entire dataset. A hands-on example I hope that the mentioned use cases got you excited about giving the streaming client a go! To use the benefits of the streaming client, we need to store our project on DagsHub and version the data with DVC. Please refer to to see how to set everything up. this article The goal of this tutorial is to show how quickly we can get a project up and running using the streaming client. That is why we forked an already existing project and we will show how to quickly start the training of our neural network in the cloud. For that purpose, we will use Google Colab, but you can use other cloud platforms such as AWS, etc. The project we forked is a TensorFlow implementation of CheXNet, which is a 121-layer CNN used for detecting pneumonia from chest X-rays. The original implementation is trained on the ChestX-ray14 dataset (available ), which is currently the largest publicly available chest X-ray dataset with over 100,000 images. The dataset is over 45 GB and is divided into 14 different directories, each one dedicated to a different disease. To reduce the training time of this experiment, we use a subsampled version of the dataset which is only 1GB. on Kaggle Before starting, it is worth mentioning that it is not always beneficial to use DDA. Before starting this project, I tried playing around with DDA for my . That is when I encountered an edge case in which passing a single batch during the training of the neural network was faster than downloading the batch on demand. This made the training of the first epoch much longer than downloading the entire dataset up front and only then running the training step normally. Hence, the images used for training must be large enough (in terms of their resolution/size) so that the training step of a single batch takes longer than downloading the next one. Mario vs. Wario classifier To follow along, you can use this . Notebook in Google Colab Setting up the project I chose to fork the project to my own account in order to use features such as experiment tracking with MLflow. However, you can just as well directly clone a repo and train the model without creating a fork. After opening a Notebook, we need to install some libraries: !pip install dagshub omegaconf mlflow Then, we import the required libraries: import datetime
import os
from IPython.display import display, Image The list of imports is rather short, as most of the libraries (for example, used for training the NNs) are loaded in the individual scripts. Then, we define a few constants containing values such as the owner of the repository, the name of the repository we want to clone, and the branch we want to use. keras # repo to use
REPO_OWNER= "eryk.lewinson"
REPO_NAME= "CheXNet"
REPO_BRANCH= "streaming" Having defined the required constants, we can use the handy functionality to initialize the DagsHub repository. We can then easily log the experiments with MLFlow, get access tokens, etc. We run the following snippet to set up the project in Colab: init import dagshub
dagshub.init(repo_name=REPO_NAME, repo_owner=REPO_OWNER) After running the cell, we will be prompted to authenticate in our browser. Then, we can clone the repository using the command: git clone !git clone https://{USER_NAME}:{dagshub.auth.get_token()}@dagshub.com/{REPO_OWNER}/{REPO_NAME}.git As the next step, we change the directory to the CheXNet one: %cd /content/{REPO_NAME} And then we change the branch to the one that contains the codebase we can use together with the streaming client: !git checkout {REPO_BRANCH} As we have mentioned before, the branch uses the full 45GB dataset, while the branch trains the neural network on a subsampled dataset. master streaming At this point, we are done with the setup and are ready to take the streaming client for a spin. Inspecting the dataset First, let’s explore our dataset. After cloning the codebase, we can see that the data is versioned with DVC as we can see the corresponding tracking files. However, we cannot actually inspect it from Colab. At least not yet :) Let’s use the streaming client for the task. In this tutorial, we use the Python Hooks implementation of DDA. As such, we need to run the following two lines: from dagshub.streaming import install_hooks
install_hooks() At this point, we can inspect the images using code, even though the folders are not visible in the directory tree. As we know the structure of the directories containing the images, we can use the following snippet with a relative path to print all the images in a requested directory: os.listdir("data_labeling/data/images_001/images") As you can see, this is regular Python code and the streaming client handles everything for us in the background. Executing the snippet prints the following list: ['00000417_005.png',
 '00000583_047.png',
 '00000683_002.png',
 '00000796_001.png',
 '00001088_024.png',
 '00000013_006.png',
 '00000547_009.png',
 '00000640_000.png',
 '00000732_004.png',
…] We can also display the image using the following snippet: display(Image(filename="data_labeling/data/images_001/images/00000417_005.png")) As we have mentioned before, the streaming client downloads the data on request and caches it for later use. As such, the image we have displayed was actually downloaded and we can see it in the directory tree: Now we can take the next step and start training the neural network! Training a neural network As we have already mentioned, we do not have to spend time modifying the code used for training the NN. We just need to add the already familiar two lines of code to the script. You might ask why are we doing it again when we have already executed that cell before. That is because when we are calling a script from Colab, the script runs in a separate Python context. As such, the streaming setup is no longer applied to it. train.py To make the codebase even more generic, we can use the following conditional statement combined with the setup: install_hooks if "STREAM" in sys.argv:
    from dagshub.streaming.filesystem import install_hooks
    install_hooks() is essentially an array containing the command line arguments, that is, the values that are passed while calling the script. To illustrate, we can run the training script using the following snippet: sys.argv %run modeling/src/train.py STREAM To run the script without utilizing the streaming client, we simply have to remove the argument. STREAM As soon as we run the command, we will see that the directory tree will start populating with the images that were requested for a particular batch. And that was it! By adding only two lines of code we can leverage the streaming client to start downloading the versioned data on demand. Additionally, you might want to track your experiment with MLflow. To do so using DagsHub’s setup, you also need to modify the constant in the file. MLFLOW_TRACKING_URL src/const.yaml Wrapping up In this article, we demonstrated how to use DagsHub’s streaming client to download the dataset on demand. This way, we can almost immediately start the training of our models, without first pulling all of the versioned data to our machine, be it locally or in the cloud. As you could see, the streaming client really shines for tasks such as computer vision, but it can come in handy while solving other problems as well. You can find the Notebook used in this article . The project’s codebase is available . As always, any constructive feedback is welcome. You can reach out to me on or in the comments. here here Twitter Resources https://dagshub.com/docs/feature_guide/direct_data_access/ Rajpurkar, P., Irvin, J., Zhu, K., Yang, B., Mehta, H., Duan, T., ... & Ng, A. Y. (2017). Chexnet: Radiologist-level pneumonia detection on chest x-rays with deep learning. arXiv preprint arXiv:1711.05225. https://www.kaggle.com/datasets/paultimothymooney/chest-xray-pneumonia

Ecolab News on
HackerNoon and Around the Web

ecolab.com

47000 employees

Since 1923

59282 at Alexa

📉 Stock Prices

Ecolab Story Mentions

Articles Around the Web

Read More Tech Stories Related to #Ecolab

Ecolab News on HackerNoon and Around the Web