def write_clip(stimulus, stimtime, output_dir, num_channels, sample_rate, data): # Set format for Audiolab file export AU or WAV 16bit (encoding originally 'float32') format1 = audio.Format(type='au', encoding='pcm16') format2 = audio.Format(type='wav', encoding='pcm16') # Single File output -- Needs tweaking to work right if stimulus == 'sound': nameSingle = output_dir + '/' + str(stimtime.secs) + '.' + str(stimtime.nsecs) + '_' + stimulus + '_All.wav' single_file = audio.Sndfile(nameSingle, 'w', format2, num_channels, sample_rate) file_name = output_dir + '/' + str(stimtime.secs) + '.' + str(stimtime.nsecs) + '_' + stimulus + '_Channel-1.wav' sound_file = audio.Sndfile(file_name, 'w', format2, 1, sample_rate) # Create list of sound file entities with unique channel names # Each channel output separately ## channel_files = [] ## for channel in range(0,num_channels): ## name = output_dir + '/' + str(stimtime.secs) + '.' + str(stimtime.nsecs) + '_' + stimulus + '_Channel-%d.wav' % (channel+1) ## channel_files.append(audio.Sndfile(name, 'w', format2, 1, sample_rate)) # Manipulate the data to each individual sound file for line in data: soundarray = array(line) # shape: (16384,) soundarray = reshape(soundarray, (len(soundarray)/num_channels, num_channels)) # shape: (4096, 4) #single_file.write_frames(soundarray) soundarray = array_split(soundarray, num_channels, axis=1) # splits into list with 4 arrays of shape (4096, 1) sound_file.write_frames(soundarray[0]) ## for channel in range(0,num_channels): ## channel_files[channel].write_frames(soundarray[channel]) # Finish each of the files sound_file.sync()
def write(self, filename, encoding="pcm16", endianness="file", fileformat=None): if not fileformat: fileformat = os.path.basename(filename).split(".")[-1] format = AL.Format(fileformat, encoding, endianness) f = AL.Sndfile(filename, "w", format, self.channels, self.samplerate) f.write_frames(self.samples) f.close()
def process_wavfiles(dirname, prepend_dir, audiotype, speaker_name, spk_id, db, prompts, dbfile): dirlist = os.listdir(prepend_dir + dirname + '/' + audiotype + '/') wavfile_ids = [] for fname in dirlist: try: sfile = audio.Sndfile( prepend_dir + dirname + '/' + audiotype + '/' + fname, 'r') except: print prepend_dir, dirname, audiotype, fname assert False, "could not open soundfile" #print sfile.nframes, sfile.encoding, sfile.format, sfile.samplerate, sfile.channels, sfile.file_format #sndvec = sfile.read_frames(sfile.nframes) #sndvec_comp = sndvec.tolist() sndfile = open(prepend_dir + dirname + '/' + audiotype + '/' + fname, 'r') #print np.size(sndvec,0), np.size(sndvec,1) #audio.play(sndvec, sfile.samplerate) if fname.split('.')[0] in prompts.keys(): insert_prompt = prompts[fname.split('.')[0]] else: insert_prompt = '' #start = time.time() #try: #audio_id = db.audio.insert({'frames': sfile.nframes, 'encoding': sfile.encoding, # 'rate': sfile.samplerate, 'data': oid, # 'ch': sfile.channels, 'speaker': spk_id, #'type': sndvec.dtype.name, # 'prompt': insert_prompt, 'filename': fname.split('.')[0], 'speaker_name': speaker_name}) #except pymongo.errors.AutoReconnect: # print db.error() # print db.last_status() audio_rec = Audio() audio_rec.frames = sfile.nframes audio_rec.encoding = fname.split('.')[1] audio_rec.rate = sfile.samplerate audio_rec.data = sndfile audio_rec.data.content_type = 'audio/' + audiotype audio_rec.ch = sfile.channels audio_rec.speaker = spk_id audio_rec.prompt = insert_prompt audio_rec.filename = fname.split('.')[0] audio_rec.speaker_name = speaker_name try: audio_rec.save(safe=True) audio_id = audio_rec.id except OperationError: assert False, "Insert failed" if audio_id: wavfile_ids.append(audio_id) else: assert False, "Error on insert" return wavfile_ids
def read_soundfile(filename): soundfile = al.Sndfile(filename, 'r') signal = soundfile.read_frames(soundfile.nframes) if soundfile.channels == 1: return signal, soundfile.samplerate else: return signal[:, 0], soundfile.samplerate
def to_sound_file(self, c, filepath): output_file = audiolab.Sndfile( filepath, 'w', audiolab.Format(type='aiff', encoding=self.encoding), self.channels, self.samplerate) output_file.write_frames(self.to_numpy(c)) output_file.close()
def __iter__(self): if isinstance(self.filename, str): f = audiolab.Sndfile(self.filename) elif np.iterable(self.filename): f = MockSndfile(self.filename, samplerate=44100) else: raise ValueError, 'Invalid filename: %s' % self.filename nbuf = self.nbuf end = self.end if not end: end = f.nframes if not nbuf: nbuf = 10*f.samplerate pos = f.seek(self.start) nremaining = end - pos while nremaining > 0: if nremaining < nbuf: nbuf = nremaining try: yield f.read_frames(nbuf) nremaining -= nbuf except RuntimeError: nremaining = 0 f.close()
def make_output_files(inputFilenames, outputdir, auformat, samplerate): logging.debug("Making output files in directory %s" % outputdir) outputFiles = [] for infile in inputFilenames: ofn = "%s/%s" % (outputdir, os.path.basename(infile)) outputFiles.append(al.Sndfile(ofn, 'w', auformat, 1, samplerate)) return outputFiles
def get_audio(filepath, seg_start, seg_duration, targetfs=None, verbose=True): """ for use only with wav files from rwc database """ # rewriting using scikits.audiolab import scikits.audiolab as audiolab # small hack search for alternate if not op.exists(filepath): filepath = op.splitext(filepath)[0] + '.wav' if not op.exists(filepath): filepath = op.splitext(filepath)[0] + '.WAV' sndfile = audiolab.Sndfile(filepath, 'r') fs = sndfile.samplerate (n, c) = (sndfile.nframes, sndfile.channels) if verbose: print "Reading" # initalize position sndfile.seek(int(seg_start * fs), 0, 'r') audiodata = sndfile.read_frames(int(seg_duration * fs)) sndfile.close() if verbose: print "Done" if targetfs is not None and not (targetfs == fs): if verbose: print "Resampling" sig = Signal(audiodata, fs) sig.resample(targetfs) audiodata = sig.data fs = targetfs if verbose: print "Done" return audiodata, fs
def get_max_level(filename): max_value = 0 buffer_size = 4096 audio_file = audiolab.Sndfile(filename, 'r') n_samples_left = audio_file.nframes while n_samples_left: to_read = min(buffer_size, n_samples_left) try: samples = audio_file.read_frames(to_read) except RuntimeError: # this can happen with a broken header break # convert to mono by selecting left channel only if audio_file.channels > 1: samples = samples[:, 0] max_value = max(max_value, numpy.abs(samples).max()) n_samples_left -= to_read audio_file.close() return max_value
def get_audio_data(self, basedir=TIMIT_DIR): import scikits.audiolab as al filename = os.path.join(basedir, self.usage, self.dialect, self.sex + self.speaker_id, self.sentence_id + '.wav') f = al.Sndfile(filename, 'r') data = f.read_frames(f.nframes, dtype=np.float64) return data[self.start:self.stop]
def _load_audio_file(self): source = audiolab.Sndfile(self.filename, 'r') # audiolab scales the range by the bit depth automatically so the dynamic range is now [-1.0, 1.0] # we rescale it to the range [0.0, 1.0] self.time_series = ( source.read_frames(source.nframes, dtype=self.precision) + 1) / 2 self.sample_rate = source.samplerate
def read(self, filename, dtype=np.float64): f = AL.Sndfile(filename, 'r') self.samplerate = f.samplerate self.samples = f.read_frames(f.nframes, dtype=dtype) if len(self.samples.shape) == 2: self.channels = self.samples.shape[1] else: self.channels = 1 f.close()
def write_file(path, frames, rate=SAMPLE_RATE): format = audiolab.Format("wav", "pcm16") sndfile = audiolab.Sndfile(path, "w", format=format, channels=len(frames.shape), samplerate=rate) sndfile.write_frames(frames) sndfile.sync
def get_framer_audio_audiolab(filename, size, hop): from scikits import audiolab loader = audiolab.Sndfile(filename) sr = loader.samplerate nframes = loader.nframes nchannels = loader.channels framer = framer_audio_audiolab(loader, size, hop) return framer, sr, int(math.ceil(float(nframes) / hop)), nchannels, loader
def write_clip(stimulus, stimtime, dirname, num_channels, sample_rate, data): format = audio.Format(type='au', encoding='float32') name = dirname + '/' + str(stimtime.secs) + '.' + str( stimtime.nsecs) + '_' + stimulus + '.au' print name soundfile = audio.Sndfile(name, 'w', format, num_channels, sample_rate) for d in data: sndarray = array(d) sndarray = reshape(sndarray, (len(sndarray) / num_channels, num_channels)) soundfile.write_frames(sndarray) soundfile.sync()
def read_file(path): if al != None: soundfile = al.Sndfile(path, 'r') return soundfile.read_frames(soundfile.nframes) else: try: print("Warning: no audiolab. Trying to read WAV: " + path) wav = wavfile.read(path)[1] wav = np.float64(wav) / np.iinfo(np.int16).max return wav except ValueError: return None
def __init__(self, source_file, target_file): sf = audiolab.Sndfile(source_file) self.encoding = sf.encoding self.channels = 1 # We only load first channel self.samplerate = sf.samplerate sf.close() self.source = load_sound_file(source_file) self.target = load_sound_file(target_file) self.split_source = [] for split_range in num_zero_crossings_per_chunk: print split_range self.split_source += split_by_zero_crossings( self.source, split_range) self.max_gene = len(self.split_source) - 1 self.ideal_length = len(self.target)
def audio_test(): aud = Audio.objects.first() print 'Frames: %i' % aud.frames print 'Encoding: %s' % aud.encoding print 'Rate: %i' % aud.rate print 'Channels: %i' % aud.ch print 'Speaker: %s' % Speaker.objects.with_id(aud.speaker).name print 'Filename: %s' % aud.filename print 'Speaker Name: %s' % aud.speaker_name fname_out = self_extract(aud.data, aud.filename + '.' + aud.encoding) sfile = audio.Sndfile(fname_out, 'r') sndvec = sfile.read_frames(aud.frames) audio.play(sndvec, aud.rate)
def __init__(self, input_filename, fft_size, window_function=numpy.hanning): max_level = get_max_level(input_filename) self.audio_file = audiolab.Sndfile(input_filename, 'r') self.fft_size = fft_size self.window = window_function(self.fft_size) self.spectrum_range = None self.lower = 100 self.higher = 22050 self.lower_log = math.log10(self.lower) self.higher_log = math.log10(self.higher) self.clip = lambda val, low, high: min(high, max(low, val)) # figure out what the maximum value is for an FFT doing the FFT of a DC signal fft = numpy.fft.rfft(numpy.ones(fft_size) * self.window) max_fft = (numpy.abs(fft)).max() # set the scale to normalized audio and normalized FFT self.scale = 1.0/max_level/max_fft if max_level > 0 else 1
def read_file(path, duration=None, rate=SAMPLE_RATE): wav_file = path + ".wav" m4a_file = path + ".m4a" if not os.path.exists(wav_file): subprocess.call( "/usr/bin/afconvert -f WAVE -d LEI16@44100 {0} {1}".format( m4a_file, wav_file), shell=True) sndfile = audiolab.Sndfile(wav_file, samplerate=rate) nframes = sndfile.nframes if duration != None: nframes = duration * SAMPLE_RATE return sndfile.read_frames(nframes, dtype=np.float64)
def gen(chain, filepath): chain_depth = chain["chain_depth"] bin_size = chain["bin_size"] # Reset the bucket index to its starting value bucket_index = 0 num_buckets = 2 / bin_size + 1 # The total number of buckets, including one special bucket for before the start of the audio. for i in range(chain_depth): bucket_index = bucket_index * num_buckets + num_buckets - 1 new_data = np.empty([chain["samplerate"] * 15]) # 15 seconds of sound try: for i in range(new_data.size): if i % (5 * chain["samplerate"] ) == 0: # Print progress every 5 seconds print i / chain["samplerate"] tc = chain[bucket_index] new_datum = 0 #print tc weighted_index = random.randrange(tc["sum"]) for k in tc.keys(): if k not in ["sum", "samplerate", "bin_size", "chain_depth"]: if weighted_index < tc[k]: new_datum = k break else: weighted_index -= tc[k] new_data[i] = new_datum #print new_data[0:i] # Compute the bucket_index for the next iteration val = (new_data[i] - new_data[i] % bin_size) / bin_size + 1 / bin_size print val bucket_index = int((bucket_index * num_buckets + val) % (num_buckets**chain_depth)) finally: format = audiolab.Format('wav') f3 = audiolab.Sndfile(filepath, 'w', format, 1, chain["samplerate"]) f3.write_frames(new_data) f3.close()
def create_data(f, s): # Write orange tab file statistical information: f.write('filename\tHZCRR\tLSTER\tSF\tspeech-music\n') f.write('discrete\tcontinuous\tcontinuous\tcontinuous\tspeech music\n') f.write('ignore\t\t\t\tclass\n') # for each file in the directory specified with s, for infile in glob.glob('data/' + s + '/*.wav'): file, ext = os.path.splitext(infile) aud = al.Sndfile(infile, 'r') aud = (aud, file[-4:] + ext) if aud[1][:2] == 'sp': audioClass = 'speech' else: audioClass = 'music' data.append(aud) # Add the audio file and name tupple to list featTup = evaluate(aud) # Give the feature tupple of the file # Write the results to the appropriate .tab file f.write(featTup[0] + '\t' + str(featTup[1]) + '\t' + str(featTup[2]) + '\t' + str(featTup[3]) + '\t' + audioClass + '\n')
def get_spectrogram(filename, fft_length): fp = audiolab.Sndfile(filename, 'r') sample_rate = fp.samplerate total_num_samps = fp.nframes num_fft = (total_num_samps / fft_length ) - 2 # create temporary working array fft_buckets = np.zeros((num_fft, fft_length), float) channels = fp.channels # read in the data from the file for i in range(num_fft): frames = fp.read_frames(fft_length) if channels == 2: # TODO: figure out how to combine channels appropriately fft_buckets[i,:] = frames[:,0] - 128.0 elif channels == 1: fft_buckets[i,:] = frames - 128.0 else: raise Exception("Unsupported # of channels: %d" % channels) # Window the data fft_buckets = fft_buckets * np.hamming(fft_length) # Transform with the FFT, Return Power freq_pwr = 10*np.log10(1e-20 + abs(rfft(fft_buckets, fft_length))) # Plot the result n_out_pts = (fft_length / 2) + 1 y_axis_hz = 0.5 * float(sample_rate) / n_out_pts * np.arange(n_out_pts) y_axis = y_axis_hz / 1000 x_axis = (total_num_samps / float(sample_rate)) / num_fft * np.arange(num_fft) plt.xlabel('Time (sec)') plt.ylabel('Frequency (kHz)') plt.pcolormesh(x_axis, y_axis, freq_pwr.transpose()) plt.xlim([0,x_axis.max()]) plt.ylim([0,y_axis.max()]) plt.colorbar() plt.show()
def run(): # NOTE: Replace this with the name of the test example to perform SS on test_name = "grace_short" wf = skal.Sndfile("%s\\..\\..\\test\\%s.wav" % (SCRIPT_PATH, test_name), "r") p = pa.PyAudio() width = int(wf.encoding[-2:])/8 fs = wf.samplerate # NOTE: Replace this with the names of the instruments that are in the audio user_instr_names = ['piano', 'trumpet'] stream = p.open(format=p.get_format_from_width(4), channels=1, rate=wf.samplerate, output=True) with open(MODEL_PATH, 'rb') as template_file: templates = cPickle.load(template_file) instr_to_cols = dict() cols = [] idx = 0 for instr in user_instr_names: instr_templates = templates[instr] L = 0 # For now, we're just discarding the pitch info for feature, chroma, octave in instr_templates: cols.append(feature) L += feature.shape[1] instr_to_cols[instr] = (idx, idx + L) idx += L W = np.concatenate(cols, axis=1) #encoded_frames = dict(zip(user_instr_names, [[] for _ in range(len(user_instr_names))])) raw_frames = dict(zip(user_instr_names, [[] for _ in range(len(user_instr_names))])) divergence = [] # NOTE: Change this to use the adaptive algorithm or not adaptive = False threshold = 3 src_sep = plca_learn.AdaptiveSourceSeparator(W, user_instr_names, instr_to_cols, threshold, fs, CHUNK_SIZE, adaptive) i = 0 frames_left = wf.nframes while frames_left > 0: frames_requested = min(CHUNK_SIZE, frames_left) data = wf.read_frames(frames_requested, dtype=np.float32) processed_frames, div = src_sep.process_segment(data) for instr in processed_frames: raw_source = processed_frames[instr] #encoded_frames[instr].append(encoded_source) raw_frames[instr].append(raw_source) divergence.append(div) i += 1 frames_left -= frames_requested print "========= Frames Completed: %d/%d ==========" % (wf.nframes - frames_left, wf.nframes) print "Done processing frames." stream.stop_stream() stream.close() p.terminate() format = skal.Format('wav') mode_desc = "-adapt" if adaptive else "-noadapt" for instr, audio_data in raw_frames.items(): output = skal.Sndfile("%s\\..\\..\\%s-separated-%s%s.wav" % (SCRIPT_PATH, test_name, instr, mode_desc),\ 'w', format, 1, fs) for frame in audio_data: output.write_frames(frame) output.close() wf.close() with open("%s\\..\\..\\divergence_results-%s%s.txt" % (SCRIPT_PATH, test_name, mode_desc), 'w+') as f: f.write("Divergence Results\n") f.write("====================\n\n") for i, div in enumerate(divergence): f.write(" -- Segment %d: %f\n" % (i, div))
def create_data(sig, label): mfcc = get_mfcc(sig, freq, winstep=window_step, winlen=window_size, nfft=2048, lowfreq=lowfreq, highfreq=highfreq, numcep=size, nfilt=size+2) num_label = label_dic[label]*np.ones(len(mfcc)) time_per_occurrence_class[label_dic[label]].append((stop - start) / (10.0 ** 7)) return mfcc, num_label ####### Main Loop ########## for i in xrange(len(file_list)): lab_name = file_list[i] # os.path.split(os.path.join(wav_dir,file_list[i]))[1] if '~' in lab_name: continue with open(os.path.join(cur_dir, file_list[i]), 'r') as f: lines = f.readlines() wave_name = os.path.join(wav_dir, lab_name[:-4]+'.wav') f = audlab.Sndfile(wave_name, 'r') freq = f.samplerate nframes = f.nframes frames_recovered = 0 for j in xrange(len(lines)): try: cur_line = lines[j].split() start = int(cur_line[0]) stop = int(cur_line[1]) label = cur_line[2] length = stop / 10.0 ** 7 - start / 10.0 ** 7 audio = f.read_frames(np.floor(freq * length)) if label in label_dic: signal = audio # audio/math.sqrt(energy) time = np.sum(time_per_occurrence_class[label_dic[label]]) if time < threshold:
import scikits.audiolab as audio import matplotlib.pyplot as plt import random def frequencyFilter(signal): print "Len signal:", len(signal) starting_freq = 0 ending_freq = 190000 #len(signal) for i in range(0, len(signal)): signal[i] *= 2 if starting_freq < i < ending_freq: signal[i] = 0 def processWithNumpy(signal): transformedSignal = numpy.fft.fft(signal) frequencyFilter(transformedSignal) cleanedSignal = numpy.fft.ifft(transformedSignal) return numpy.array(cleanedSignal, dtype=numpy.float64) # Must be wav files. infile = sys.argv[1] outfile = sys.argv[2] (inputSignal, samplingRate, bits) = audio.wavread(infile) outputSignal = processWithNumpy(inputSignal) outputFile = audio.Sndfile(outfile, 'w', audio.Format('wav'), 1, samplingRate) outputFile.write_frames(outputSignal) outputFile.close()
def extract_specific_interval(self, interval_start, interval_end): """ Overload if special behaviour is required when a series ends. """ interval_start = int(interval_start) interval_end = int(interval_end) if interval_start >= interval_end: raise ValueError( "Requested interval's start point is past the requested end point." ) elif interval_start > self.time_series.size: if self.repeat: interval_end = interval_end - interval_start interval_start = 0 else: raise ValueError( "Requested interval's start point is past the end of the time series." ) if interval_end < self.time_series.size: interval = self.time_series[interval_start:interval_end] else: requested_interval_size = interval_end - interval_start remaining_signal = self.time_series[interval_start:self. time_series.size] if self.next_file == len(self.sound_files) and self.repeat: self.next_file = 0 if self.next_file < len(self.sound_files): next_source = audiolab.Sndfile( self.sound_files[self.next_file], 'r') self.next_file += 1 if next_source.samplerate != self.sample_rate: raise ValueError( "All sound files must be of the same sample rate") if self.gap_between_sounds > 0: remaining_signal = hstack( (remaining_signal, zeros(int(self.gap_between_sounds * self.sample_rate), dtype=self.precision))) self.time_series = hstack( (remaining_signal, next_source.read_frames(next_source.nframes, dtype=self.precision))) interval = self.time_series[0:requested_interval_size] self._next_interval_start = requested_interval_size else: self.warning("Returning last interval of the time series.") self._next_interval_start = self.time_series.size + 1 samples_per_interval = self.interval_length * self.sample_rate interval = hstack( (remaining_signal, zeros(samples_per_interval - remaining_signal.size))) return interval
#Frame Rate used by api speech from google fr=16000. #using audiolab to read wav file Signal, fs = audiolab.wavread(File)[:2] #changing the original sample rate to 16000fs fast mode Signal = resample(Signal, fr/float(fs), 'sinc_best') #changing sample rate from audio file using scipy this is a bit slow #Signal=scipy.signal.resample(Signal,int(round(len(Getsignal)*fr)/float(fs)),window=None) # file Format type fmt = audiolab.Format('flac', 'pcm16') nchannels = 1 # making the file .flac afile = audiolab.Sndfile(FileNameTmp, 'w', fmt, nchannels, fr) #writing in the file afile.write_frames(Signal) #Sending to google the file .flac url = "https://www.google.com/speech-api/v1/recognize?xjerr=1&client=chromium&lang=pt-BR" flac=open(FileNameTmp,"rb").read() header = {'Content-Type' : 'audio/x-flac; rate=16000'} req = urllib2.Request(url, flac, header) data = urllib2.urlopen(req) print data.read() remove(FileNameTmp)
import sys import numpy as np import scikits.audiolab as audiolab from keras.models import Sequential from keras.layers.core import Activation, Dense from keras.layers.recurrent import LSTM from keras.layers.embeddings import Embedding from keras.utils import np_utils, generic_utils f = audiolab.Sndfile('05 Woodstock.aif', 'r') seq_len = 50 buckets = 2048 hidden_layer_size = 256 batch_size = 128 np_epoch = 10 output_n_frames = 44100*1 data = ((f.read_frames(f.nframes)[:,0] + 1.0)*(buckets/2)) data = data.astype(int) sampling_rate = f.samplerate nframes = f.nframes f.close() model = Sequential() model.add(Embedding(buckets, hidden_layer_size, input_length=seq_len)) model.add(LSTM(output_dim=hidden_layer_size, activation="sigmoid", inner_activation="hard_sigmoid", init="uniform")) model.add(Dense(input_dim=hidden_layer_size, output_dim=buckets, init="glorot_uniform")) model.add(Activation("softmax"))
""" Minimal character-level Vanilla RNN model. Written by Andrej Karpathy (@karpathy) BSD License """ import numpy as np import scikits.audiolab as audiolab f = audiolab.Sndfile('05 Woodstock.aif', 'r') data = f.read_frames(f.nframes)[:, 0] # Gets first channel of the audio file sampling_rate = f.samplerate f.close() # data I/O chars = list(set(data)) data_size, vocab_size = len(data), len(chars) print 'data has %d characters, %d unique.' % (data_size, vocab_size) char_to_ix = {ch: i for i, ch in enumerate(chars)} ix_to_char = {i: ch for i, ch in enumerate(chars)} # hyperparameters hidden_size = 100 # size of hidden layer of neurons seq_length = 25 # number of steps to unroll the RNN for learning_rate = 1e-1 # model parameters Wxh = np.random.randn(hidden_size, vocab_size) * 0.01 # input to hidden Whh = np.random.randn(hidden_size, hidden_size) * 0.01 # hidden to hidden Why = np.random.randn(vocab_size, hidden_size) * 0.01 # hidden to output bh = np.zeros((hidden_size, 1)) # hidden bias